import ctypes, os
from typing import Optional, AnyStr
from .enums import *# Load core module
import platform
core = None
_base_path = None
core_platform = platform.system()
if core_platform == "Darwin":
_base_path = os.path.join(os.path.dirname(__file__), "..", "..", "..", "MacOS")
core = ctypes.CDLL(os.path.join(_base_path, "libbinaryninjacore.dylib"))
elif core_platform == "Linux":
_base_path = os.path.join(os.path.dirname(__file__), "..", "..")
core = ctypes.CDLL(os.path.join(_base_path, "libbinaryninjacore.so.1"))
elif (core_platform == "Windows") or (core_platform.find("CYGWIN_NT") == 0):
_base_path = os.path.join(os.path.dirname(__file__), "..", "..")
core = ctypes.CDLL(os.path.join(_base_path, "binaryninjacore.dll"))
else:
raise Exception("OS not supported")
def cstr(var: Optional[AnyStr]) -> Optional[bytes]:
if var is None:
return None
if isinstance(var, bytes):
return var
return var.encode("utf-8")
def pyNativeStr(arg: AnyStr) -> str:
if isinstance(arg, str):
return arg
else:
return arg.decode('utf8')
def free_string(value:ctypes.c_char_p) -> None:
BNFreeString(ctypes.cast(value, ctypes.POINTER(ctypes.c_byte)))
# Type definitions
ActionTypeEnum = ctypes.c_int
class BNActiveAnalysisInfo(ctypes.Structure):
pass
BNActiveAnalysisInfoHandle = ctypes.POINTER(BNActiveAnalysisInfo)
class BNActivity(ctypes.Structure):
pass
BNActivityHandle = ctypes.POINTER(BNActivity)
class BNAddressRange(ctypes.Structure):
pass
BNAddressRangeHandle = ctypes.POINTER(BNAddressRange)
class BNAnalysisCompletionEvent(ctypes.Structure):
pass
BNAnalysisCompletionEventHandle = ctypes.POINTER(BNAnalysisCompletionEvent)
class BNAnalysisContext(ctypes.Structure):
pass
BNAnalysisContextHandle = ctypes.POINTER(BNAnalysisContext)
class BNAnalysisInfo(ctypes.Structure):
pass
BNAnalysisInfoHandle = ctypes.POINTER(BNAnalysisInfo)
AnalysisModeEnum = ctypes.c_int
class BNAnalysisParameters(ctypes.Structure):
pass
BNAnalysisParametersHandle = ctypes.POINTER(BNAnalysisParameters)
class BNAnalysisProgress(ctypes.Structure):
pass
BNAnalysisProgressHandle = ctypes.POINTER(BNAnalysisProgress)
AnalysisSkipReasonEnum = ctypes.c_int
AnalysisStateEnum = ctypes.c_int
AnalysisWarningActionTypeEnum = ctypes.c_int
class BNArchitecture(ctypes.Structure):
pass
BNArchitectureHandle = ctypes.POINTER(BNArchitecture)
class BNArchitectureAndAddress(ctypes.Structure):
pass
BNArchitectureAndAddressHandle = ctypes.POINTER(BNArchitectureAndAddress)
class BNBackgroundTask(ctypes.Structure):
pass
BNBackgroundTaskHandle = ctypes.POINTER(BNBackgroundTask)
class BNBaseStructure(ctypes.Structure):
pass
BNBaseStructureHandle = ctypes.POINTER(BNBaseStructure)
class BNBasicBlock(ctypes.Structure):
pass
BNBasicBlockHandle = ctypes.POINTER(BNBasicBlock)
class BNBasicBlockEdge(ctypes.Structure):
pass
BNBasicBlockEdgeHandle = ctypes.POINTER(BNBasicBlockEdge)
class BNBinaryDataNotification(ctypes.Structure):
pass
BNBinaryDataNotificationHandle = ctypes.POINTER(BNBinaryDataNotification)
class BNBinaryReader(ctypes.Structure):
pass
BNBinaryReaderHandle = ctypes.POINTER(BNBinaryReader)
class BNBinaryView(ctypes.Structure):
pass
BNBinaryViewHandle = ctypes.POINTER(BNBinaryView)
class BNBinaryViewEvent(ctypes.Structure):
pass
BNBinaryViewEventHandle = ctypes.POINTER(BNBinaryViewEvent)
BinaryViewEventTypeEnum = ctypes.c_int
class BNBinaryViewType(ctypes.Structure):
pass
BNBinaryViewTypeHandle = ctypes.POINTER(BNBinaryViewType)
class BNBinaryWriter(ctypes.Structure):
pass
BNBinaryWriterHandle = ctypes.POINTER(BNBinaryWriter)
class BNBoolWithConfidence(ctypes.Structure):
pass
BNBoolWithConfidenceHandle = ctypes.POINTER(BNBoolWithConfidence)
BranchTypeEnum = ctypes.c_int
class BNCallingConvention(ctypes.Structure):
pass
BNCallingConventionHandle = ctypes.POINTER(BNCallingConvention)
CallingConventionNameEnum = ctypes.c_int
class BNCallingConventionWithConfidence(ctypes.Structure):
pass
BNCallingConventionWithConfidenceHandle = ctypes.POINTER(BNCallingConventionWithConfidence)
class BNChangelogEntry(ctypes.Structure):
@property
def notes(self):
return pyNativeStr(self._notes)
@notes.setter
def notes(self, value):
self._notes = cstr(value)
BNChangelogEntryHandle = ctypes.POINTER(BNChangelogEntry)
class BNComponent(ctypes.Structure):
pass
BNComponentHandle = ctypes.POINTER(BNComponent)
class BNConstantReference(ctypes.Structure):
pass
BNConstantReferenceHandle = ctypes.POINTER(BNConstantReference)
class BNCustomArchitecture(ctypes.Structure):
pass
BNCustomArchitectureHandle = ctypes.POINTER(BNCustomArchitecture)
class BNCustomBinaryView(ctypes.Structure):
pass
BNCustomBinaryViewHandle = ctypes.POINTER(BNCustomBinaryView)
class BNCustomBinaryViewType(ctypes.Structure):
pass
BNCustomBinaryViewTypeHandle = ctypes.POINTER(BNCustomBinaryViewType)
class BNCustomCallingConvention(ctypes.Structure):
pass
BNCustomCallingConventionHandle = ctypes.POINTER(BNCustomCallingConvention)
class BNCustomDataRenderer(ctypes.Structure):
pass
BNCustomDataRendererHandle = ctypes.POINTER(BNCustomDataRenderer)
class BNCustomFlowGraph(ctypes.Structure):
pass
BNCustomFlowGraphHandle = ctypes.POINTER(BNCustomFlowGraph)
class BNCustomRelocationHandler(ctypes.Structure):
pass
BNCustomRelocationHandlerHandle = ctypes.POINTER(BNCustomRelocationHandler)
class BNCustomTransform(ctypes.Structure):
pass
BNCustomTransformHandle = ctypes.POINTER(BNCustomTransform)
class BNDataBuffer(ctypes.Structure):
pass
BNDataBufferHandle = ctypes.POINTER(BNDataBuffer)
DataFlowQueryOptionEnum = ctypes.c_int
class BNDataRenderer(ctypes.Structure):
pass
BNDataRendererHandle = ctypes.POINTER(BNDataRenderer)
class BNDataRendererContainer(ctypes.Structure):
pass
BNDataRendererContainerHandle = ctypes.POINTER(BNDataRendererContainer)
class BNDataVariable(ctypes.Structure):
pass
BNDataVariableHandle = ctypes.POINTER(BNDataVariable)
class BNDataVariableAndName(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNDataVariableAndNameHandle = ctypes.POINTER(BNDataVariableAndName)
class BNDataVariableAndNameAndDebugParser(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
@property
def parser(self):
return pyNativeStr(self._parser)
@parser.setter
def parser(self, value):
self._parser = cstr(value)
BNDataVariableAndNameAndDebugParserHandle = ctypes.POINTER(BNDataVariableAndNameAndDebugParser)
class BNDatabase(ctypes.Structure):
pass
BNDatabaseHandle = ctypes.POINTER(BNDatabase)
DeadStoreEliminationEnum = ctypes.c_int
class BNDebugFunctionInfo(ctypes.Structure):
@property
def shortName(self):
return pyNativeStr(self._shortName)
@shortName.setter
def shortName(self, value):
self._shortName = cstr(value)
@property
def fullName(self):
return pyNativeStr(self._fullName)
@fullName.setter
def fullName(self, value):
self._fullName = cstr(value)
@property
def rawName(self):
return pyNativeStr(self._rawName)
@rawName.setter
def rawName(self, value):
self._rawName = cstr(value)
BNDebugFunctionInfoHandle = ctypes.POINTER(BNDebugFunctionInfo)
class BNDebugInfo(ctypes.Structure):
pass
BNDebugInfoHandle = ctypes.POINTER(BNDebugInfo)
class BNDebugInfoParser(ctypes.Structure):
pass
BNDebugInfoParserHandle = ctypes.POINTER(BNDebugInfoParser)
DisassemblyOptionEnum = ctypes.c_int
class BNDisassemblySettings(ctypes.Structure):
pass
BNDisassemblySettingsHandle = ctypes.POINTER(BNDisassemblySettings)
class BNDisassemblyTextLine(ctypes.Structure):
pass
BNDisassemblyTextLineHandle = ctypes.POINTER(BNDisassemblyTextLine)
class BNDisassemblyTextLineTypeInfo(ctypes.Structure):
pass
BNDisassemblyTextLineTypeInfoHandle = ctypes.POINTER(BNDisassemblyTextLineTypeInfo)
class BNDisassemblyTextRenderer(ctypes.Structure):
pass
BNDisassemblyTextRendererHandle = ctypes.POINTER(BNDisassemblyTextRenderer)
class BNDownloadInstance(ctypes.Structure):
pass
BNDownloadInstanceHandle = ctypes.POINTER(BNDownloadInstance)
class BNDownloadInstanceCallbacks(ctypes.Structure):
pass
BNDownloadInstanceCallbacksHandle = ctypes.POINTER(BNDownloadInstanceCallbacks)
class BNDownloadInstanceInputOutputCallbacks(ctypes.Structure):
pass
BNDownloadInstanceInputOutputCallbacksHandle = ctypes.POINTER(BNDownloadInstanceInputOutputCallbacks)
class BNDownloadInstanceOutputCallbacks(ctypes.Structure):
pass
BNDownloadInstanceOutputCallbacksHandle = ctypes.POINTER(BNDownloadInstanceOutputCallbacks)
class BNDownloadInstanceResponse(ctypes.Structure):
pass
BNDownloadInstanceResponseHandle = ctypes.POINTER(BNDownloadInstanceResponse)
class BNDownloadProvider(ctypes.Structure):
pass
BNDownloadProviderHandle = ctypes.POINTER(BNDownloadProvider)
class BNDownloadProviderCallbacks(ctypes.Structure):
pass
BNDownloadProviderCallbacksHandle = ctypes.POINTER(BNDownloadProviderCallbacks)
EdgePenStyleEnum = ctypes.c_int
class BNEdgeStyle(ctypes.Structure):
pass
BNEdgeStyleHandle = ctypes.POINTER(BNEdgeStyle)
EndiannessEnum = ctypes.c_int
class BNEnterpriseServerCallbacks(ctypes.Structure):
pass
BNEnterpriseServerCallbacksHandle = ctypes.POINTER(BNEnterpriseServerCallbacks)
class BNEnumeration(ctypes.Structure):
pass
BNEnumerationHandle = ctypes.POINTER(BNEnumeration)
class BNEnumerationBuilder(ctypes.Structure):
pass
BNEnumerationBuilderHandle = ctypes.POINTER(BNEnumerationBuilder)
class BNEnumerationMember(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNEnumerationMemberHandle = ctypes.POINTER(BNEnumerationMember)
class BNExternalLibrary(ctypes.Structure):
pass
BNExternalLibraryHandle = ctypes.POINTER(BNExternalLibrary)
class BNExternalLocation(ctypes.Structure):
pass
BNExternalLocationHandle = ctypes.POINTER(BNExternalLocation)
class BNFileAccessor(ctypes.Structure):
pass
BNFileAccessorHandle = ctypes.POINTER(BNFileAccessor)
class BNFileMetadata(ctypes.Structure):
pass
BNFileMetadataHandle = ctypes.POINTER(BNFileMetadata)
FindFlagEnum = ctypes.c_int
FindRangeTypeEnum = ctypes.c_int
FindTypeEnum = ctypes.c_int
class BNFlagConditionForSemanticClass(ctypes.Structure):
pass
BNFlagConditionForSemanticClassHandle = ctypes.POINTER(BNFlagConditionForSemanticClass)
FlagRoleEnum = ctypes.c_int
class BNFlowGraph(ctypes.Structure):
pass
BNFlowGraphHandle = ctypes.POINTER(BNFlowGraph)
class BNFlowGraphEdge(ctypes.Structure):
pass
BNFlowGraphEdgeHandle = ctypes.POINTER(BNFlowGraphEdge)
class BNFlowGraphLayoutRequest(ctypes.Structure):
pass
BNFlowGraphLayoutRequestHandle = ctypes.POINTER(BNFlowGraphLayoutRequest)
class BNFlowGraphNode(ctypes.Structure):
pass
BNFlowGraphNodeHandle = ctypes.POINTER(BNFlowGraphNode)
FlowGraphOptionEnum = ctypes.c_int
class BNFormInputField(ctypes.Structure):
@property
def prompt(self):
return pyNativeStr(self._prompt)
@prompt.setter
def prompt(self, value):
self._prompt = cstr(value)
@property
def ext(self):
return pyNativeStr(self._ext)
@ext.setter
def ext(self, value):
self._ext = cstr(value)
@property
def defaultName(self):
return pyNativeStr(self._defaultName)
@defaultName.setter
def defaultName(self, value):
self._defaultName = cstr(value)
@property
def stringResult(self):
return pyNativeStr(self._stringResult)
@stringResult.setter
def stringResult(self, value):
self._stringResult = cstr(value)
@property
def stringDefault(self):
return pyNativeStr(self._stringDefault)
@stringDefault.setter
def stringDefault(self, value):
self._stringDefault = cstr(value)
BNFormInputFieldHandle = ctypes.POINTER(BNFormInputField)
FormInputFieldTypeEnum = ctypes.c_int
class BNFunction(ctypes.Structure):
pass
BNFunctionHandle = ctypes.POINTER(BNFunction)
FunctionAnalysisSkipOverrideEnum = ctypes.c_int
FunctionGraphTypeEnum = ctypes.c_int
class BNFunctionParameter(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNFunctionParameterHandle = ctypes.POINTER(BNFunctionParameter)
class BNFunctionRecognizer(ctypes.Structure):
pass
BNFunctionRecognizerHandle = ctypes.POINTER(BNFunctionRecognizer)
FunctionUpdateTypeEnum = ctypes.c_int
class BNHighLevelILFunction(ctypes.Structure):
pass
BNHighLevelILFunctionHandle = ctypes.POINTER(BNHighLevelILFunction)
class BNHighLevelILInstruction(ctypes.Structure):
pass
BNHighLevelILInstructionHandle = ctypes.POINTER(BNHighLevelILInstruction)
HighLevelILOperationEnum = ctypes.c_int
class BNHighlightColor(ctypes.Structure):
pass
BNHighlightColorHandle = ctypes.POINTER(BNHighlightColor)
HighlightColorStyleEnum = ctypes.c_int
HighlightStandardColorEnum = ctypes.c_int
ILBranchDependenceEnum = ctypes.c_int
class BNILBranchInstructionAndDependence(ctypes.Structure):
pass
BNILBranchInstructionAndDependenceHandle = ctypes.POINTER(BNILBranchInstructionAndDependence)
class BNILIndexRange(ctypes.Structure):
pass
BNILIndexRangeHandle = ctypes.POINTER(BNILIndexRange)
ILInstructionAttributeEnum = ctypes.c_int
class BNILReferenceSource(ctypes.Structure):
pass
BNILReferenceSourceHandle = ctypes.POINTER(BNILReferenceSource)
ImplicitRegisterExtendEnum = ctypes.c_int
class BNIndirectBranchInfo(ctypes.Structure):
pass
BNIndirectBranchInfoHandle = ctypes.POINTER(BNIndirectBranchInfo)
class BNInheritedStructureMember(ctypes.Structure):
pass
BNInheritedStructureMemberHandle = ctypes.POINTER(BNInheritedStructureMember)
class BNInstructionInfo(ctypes.Structure):
pass
BNInstructionInfoHandle = ctypes.POINTER(BNInstructionInfo)
class BNInstructionTextLine(ctypes.Structure):
pass
BNInstructionTextLineHandle = ctypes.POINTER(BNInstructionTextLine)
class BNInstructionTextToken(ctypes.Structure):
@property
def text(self):
return pyNativeStr(self._text)
@text.setter
def text(self, value):
self._text = cstr(value)
BNInstructionTextTokenHandle = ctypes.POINTER(BNInstructionTextToken)
InstructionTextTokenContextEnum = ctypes.c_int
InstructionTextTokenTypeEnum = ctypes.c_int
IntegerDisplayTypeEnum = ctypes.c_int
class BNInteractionHandlerCallbacks(ctypes.Structure):
pass
BNInteractionHandlerCallbacksHandle = ctypes.POINTER(BNInteractionHandlerCallbacks)
IntrinsicClassEnum = ctypes.c_int
class BNKeyValueStore(ctypes.Structure):
pass
BNKeyValueStoreHandle = ctypes.POINTER(BNKeyValueStore)
class BNLanguageRepresentationFunction(ctypes.Structure):
pass
BNLanguageRepresentationFunctionHandle = ctypes.POINTER(BNLanguageRepresentationFunction)
class BNLinearDisassemblyLine(ctypes.Structure):
pass
BNLinearDisassemblyLineHandle = ctypes.POINTER(BNLinearDisassemblyLine)
LinearDisassemblyLineTypeEnum = ctypes.c_int
class BNLinearViewCursor(ctypes.Structure):
pass
BNLinearViewCursorHandle = ctypes.POINTER(BNLinearViewCursor)
class BNLinearViewObject(ctypes.Structure):
pass
BNLinearViewObjectHandle = ctypes.POINTER(BNLinearViewObject)
class BNLinearViewObjectIdentifier(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNLinearViewObjectIdentifierHandle = ctypes.POINTER(BNLinearViewObjectIdentifier)
LinearViewObjectIdentifierTypeEnum = ctypes.c_int
LogLevelEnum = ctypes.c_int
class BNLogListener(ctypes.Structure):
pass
BNLogListenerHandle = ctypes.POINTER(BNLogListener)
class BNLogger(ctypes.Structure):
pass
BNLoggerHandle = ctypes.POINTER(BNLogger)
class BNLookupTableEntry(ctypes.Structure):
pass
BNLookupTableEntryHandle = ctypes.POINTER(BNLookupTableEntry)
LowLevelILFlagConditionEnum = ctypes.c_int
class BNLowLevelILFunction(ctypes.Structure):
pass
BNLowLevelILFunctionHandle = ctypes.POINTER(BNLowLevelILFunction)
class BNLowLevelILInstruction(ctypes.Structure):
pass
BNLowLevelILInstructionHandle = ctypes.POINTER(BNLowLevelILInstruction)
class BNLowLevelILLabel(ctypes.Structure):
pass
BNLowLevelILLabelHandle = ctypes.POINTER(BNLowLevelILLabel)
LowLevelILOperationEnum = ctypes.c_int
class BNMainThreadAction(ctypes.Structure):
pass
BNMainThreadActionHandle = ctypes.POINTER(BNMainThreadAction)
class BNMainThreadCallbacks(ctypes.Structure):
pass
BNMainThreadCallbacksHandle = ctypes.POINTER(BNMainThreadCallbacks)
class BNMediumLevelILFunction(ctypes.Structure):
pass
BNMediumLevelILFunctionHandle = ctypes.POINTER(BNMediumLevelILFunction)
class BNMediumLevelILInstruction(ctypes.Structure):
pass
BNMediumLevelILInstructionHandle = ctypes.POINTER(BNMediumLevelILInstruction)
class BNMediumLevelILLabel(ctypes.Structure):
pass
BNMediumLevelILLabelHandle = ctypes.POINTER(BNMediumLevelILLabel)
MediumLevelILOperationEnum = ctypes.c_int
MemberAccessEnum = ctypes.c_int
MemberScopeEnum = ctypes.c_int
class BNMemoryUsageInfo(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNMemoryUsageInfoHandle = ctypes.POINTER(BNMemoryUsageInfo)
class BNMergedVariable(ctypes.Structure):
pass
BNMergedVariableHandle = ctypes.POINTER(BNMergedVariable)
MessageBoxButtonResultEnum = ctypes.c_int
MessageBoxButtonSetEnum = ctypes.c_int
MessageBoxIconEnum = ctypes.c_int
class BNMetadata(ctypes.Structure):
pass
BNMetadataHandle = ctypes.POINTER(BNMetadata)
MetadataTypeEnum = ctypes.c_int
class BNMetadataValueStore(ctypes.Structure):
pass
BNMetadataValueStoreHandle = ctypes.POINTER(BNMetadataValueStore)
ModificationStatusEnum = ctypes.c_int
class BNNameAndType(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNNameAndTypeHandle = ctypes.POINTER(BNNameAndType)
class BNNameList(ctypes.Structure):
@property
def join(self):
return pyNativeStr(self._join)
@join.setter
def join(self, value):
self._join = cstr(value)
BNNameListHandle = ctypes.POINTER(BNNameList)
class BNNameSpace(ctypes.Structure):
@property
def join(self):
return pyNativeStr(self._join)
@join.setter
def join(self, value):
self._join = cstr(value)
BNNameSpaceHandle = ctypes.POINTER(BNNameSpace)
NameTypeEnum = ctypes.c_int
class BNNamedTypeReference(ctypes.Structure):
pass
BNNamedTypeReferenceHandle = ctypes.POINTER(BNNamedTypeReference)
class BNNamedTypeReferenceBuilder(ctypes.Structure):
pass
BNNamedTypeReferenceBuilderHandle = ctypes.POINTER(BNNamedTypeReferenceBuilder)
NamedTypeReferenceClassEnum = ctypes.c_int
class BNNavigationHandler(ctypes.Structure):
pass
BNNavigationHandlerHandle = ctypes.POINTER(BNNavigationHandler)
class BNObjectDestructionCallbacks(ctypes.Structure):
pass
BNObjectDestructionCallbacksHandle = ctypes.POINTER(BNObjectDestructionCallbacks)
class BNOffsetWithConfidence(ctypes.Structure):
pass
BNOffsetWithConfidenceHandle = ctypes.POINTER(BNOffsetWithConfidence)
class BNParameterVariablesWithConfidence(ctypes.Structure):
pass
BNParameterVariablesWithConfidenceHandle = ctypes.POINTER(BNParameterVariablesWithConfidence)
class BNParsedType(ctypes.Structure):
pass
BNParsedTypeHandle = ctypes.POINTER(BNParsedType)
class BNPerformanceInfo(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNPerformanceInfoHandle = ctypes.POINTER(BNPerformanceInfo)
class BNPlatform(ctypes.Structure):
pass
BNPlatformHandle = ctypes.POINTER(BNPlatform)
class BNPluginCommand(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
@property
def description(self):
return pyNativeStr(self._description)
@description.setter
def description(self, value):
self._description = cstr(value)
BNPluginCommandHandle = ctypes.POINTER(BNPluginCommand)
PluginCommandTypeEnum = ctypes.c_int
PluginLoadOrderEnum = ctypes.c_int
PluginOriginEnum = ctypes.c_int
PluginStatusEnum = ctypes.c_int
PluginTypeEnum = ctypes.c_int
class BNPoint(ctypes.Structure):
pass
BNPointHandle = ctypes.POINTER(BNPoint)
PointerSuffixEnum = ctypes.c_int
class BNPossibleValueSet(ctypes.Structure):
pass
BNPossibleValueSetHandle = ctypes.POINTER(BNPossibleValueSet)
class BNProject(ctypes.Structure):
pass
BNProjectHandle = ctypes.POINTER(BNProject)
class BNProjectFile(ctypes.Structure):
pass
BNProjectFileHandle = ctypes.POINTER(BNProjectFile)
class BNProjectFolder(ctypes.Structure):
pass
BNProjectFolderHandle = ctypes.POINTER(BNProjectFolder)
class BNProjectNotification(ctypes.Structure):
pass
BNProjectNotificationHandle = ctypes.POINTER(BNProjectNotification)
class BNQualifiedName(ctypes.Structure):
@property
def join(self):
return pyNativeStr(self._join)
@join.setter
def join(self, value):
self._join = cstr(value)
BNQualifiedNameHandle = ctypes.POINTER(BNQualifiedName)
class BNQualifiedNameAndType(ctypes.Structure):
pass
BNQualifiedNameAndTypeHandle = ctypes.POINTER(BNQualifiedNameAndType)
class BNQualifiedNameList(ctypes.Structure):
pass
BNQualifiedNameListHandle = ctypes.POINTER(BNQualifiedNameList)
class BNQualifiedNameTypeAndId(ctypes.Structure):
@property
def id(self):
return pyNativeStr(self._id)
@id.setter
def id(self, value):
self._id = cstr(value)
BNQualifiedNameTypeAndIdHandle = ctypes.POINTER(BNQualifiedNameTypeAndId)
class BNRange(ctypes.Structure):
pass
BNRangeHandle = ctypes.POINTER(BNRange)
class BNReferenceSource(ctypes.Structure):
pass
BNReferenceSourceHandle = ctypes.POINTER(BNReferenceSource)
ReferenceTypeEnum = ctypes.c_int
class BNRegisterInfo(ctypes.Structure):
pass
BNRegisterInfoHandle = ctypes.POINTER(BNRegisterInfo)
class BNRegisterOrConstant(ctypes.Structure):
pass
BNRegisterOrConstantHandle = ctypes.POINTER(BNRegisterOrConstant)
class BNRegisterSetWithConfidence(ctypes.Structure):
pass
BNRegisterSetWithConfidenceHandle = ctypes.POINTER(BNRegisterSetWithConfidence)
class BNRegisterStackAdjustment(ctypes.Structure):
pass
BNRegisterStackAdjustmentHandle = ctypes.POINTER(BNRegisterStackAdjustment)
class BNRegisterStackInfo(ctypes.Structure):
pass
BNRegisterStackInfoHandle = ctypes.POINTER(BNRegisterStackInfo)
class BNRegisterValue(ctypes.Structure):
pass
BNRegisterValueHandle = ctypes.POINTER(BNRegisterValue)
RegisterValueTypeEnum = ctypes.c_int
class BNRegisterValueWithConfidence(ctypes.Structure):
pass
BNRegisterValueWithConfidenceHandle = ctypes.POINTER(BNRegisterValueWithConfidence)
class BNRelocation(ctypes.Structure):
pass
BNRelocationHandle = ctypes.POINTER(BNRelocation)
class BNRelocationHandler(ctypes.Structure):
pass
BNRelocationHandlerHandle = ctypes.POINTER(BNRelocationHandler)
class BNRelocationInfo(ctypes.Structure):
pass
BNRelocationInfoHandle = ctypes.POINTER(BNRelocationInfo)
RelocationTypeEnum = ctypes.c_int
class BNRepoPlugin(ctypes.Structure):
pass
BNRepoPluginHandle = ctypes.POINTER(BNRepoPlugin)
class BNReportCollection(ctypes.Structure):
pass
BNReportCollectionHandle = ctypes.POINTER(BNReportCollection)
ReportTypeEnum = ctypes.c_int
class BNRepository(ctypes.Structure):
pass
BNRepositoryHandle = ctypes.POINTER(BNRepository)
class BNRepositoryManager(ctypes.Structure):
pass
BNRepositoryManagerHandle = ctypes.POINTER(BNRepositoryManager)
SaveOptionEnum = ctypes.c_int
class BNSaveSettings(ctypes.Structure):
pass
BNSaveSettingsHandle = ctypes.POINTER(BNSaveSettings)
class BNScriptingInstance(ctypes.Structure):
pass
BNScriptingInstanceHandle = ctypes.POINTER(BNScriptingInstance)
class BNScriptingInstanceCallbacks(ctypes.Structure):
pass
BNScriptingInstanceCallbacksHandle = ctypes.POINTER(BNScriptingInstanceCallbacks)
class BNScriptingOutputListener(ctypes.Structure):
pass
BNScriptingOutputListenerHandle = ctypes.POINTER(BNScriptingOutputListener)
class BNScriptingProvider(ctypes.Structure):
pass
BNScriptingProviderHandle = ctypes.POINTER(BNScriptingProvider)
class BNScriptingProviderCallbacks(ctypes.Structure):
pass
BNScriptingProviderCallbacksHandle = ctypes.POINTER(BNScriptingProviderCallbacks)
ScriptingProviderExecuteResultEnum = ctypes.c_int
ScriptingProviderInputReadyStateEnum = ctypes.c_int
class BNSecretsProvider(ctypes.Structure):
pass
BNSecretsProviderHandle = ctypes.POINTER(BNSecretsProvider)
class BNSecretsProviderCallbacks(ctypes.Structure):
pass
BNSecretsProviderCallbacksHandle = ctypes.POINTER(BNSecretsProviderCallbacks)
class BNSection(ctypes.Structure):
pass
BNSectionHandle = ctypes.POINTER(BNSection)
SectionSemanticsEnum = ctypes.c_int
class BNSegment(ctypes.Structure):
pass
BNSegmentHandle = ctypes.POINTER(BNSegment)
SegmentFlagEnum = ctypes.c_int
class BNSettings(ctypes.Structure):
pass
BNSettingsHandle = ctypes.POINTER(BNSettings)
SettingsScopeEnum = ctypes.c_int
class BNSnapshot(ctypes.Structure):
pass
BNSnapshotHandle = ctypes.POINTER(BNSnapshot)
class BNStackVariableReference(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNStackVariableReferenceHandle = ctypes.POINTER(BNStackVariableReference)
class BNStringReference(ctypes.Structure):
pass
BNStringReferenceHandle = ctypes.POINTER(BNStringReference)
StringTypeEnum = ctypes.c_int
class BNStructure(ctypes.Structure):
pass
BNStructureHandle = ctypes.POINTER(BNStructure)
class BNStructureBuilder(ctypes.Structure):
pass
BNStructureBuilderHandle = ctypes.POINTER(BNStructureBuilder)
class BNStructureMember(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNStructureMemberHandle = ctypes.POINTER(BNStructureMember)
StructureVariantEnum = ctypes.c_int
class BNSymbol(ctypes.Structure):
pass
BNSymbolHandle = ctypes.POINTER(BNSymbol)
SymbolBindingEnum = ctypes.c_int
class BNSymbolQueue(ctypes.Structure):
pass
BNSymbolQueueHandle = ctypes.POINTER(BNSymbolQueue)
SymbolTypeEnum = ctypes.c_int
SyncStatusEnum = ctypes.c_int
class BNSystemCallInfo(ctypes.Structure):
pass
BNSystemCallInfoHandle = ctypes.POINTER(BNSystemCallInfo)
class BNTag(ctypes.Structure):
pass
BNTagHandle = ctypes.POINTER(BNTag)
class BNTagReference(ctypes.Structure):
pass
BNTagReferenceHandle = ctypes.POINTER(BNTagReference)
TagReferenceTypeEnum = ctypes.c_int
class BNTagType(ctypes.Structure):
pass
BNTagTypeHandle = ctypes.POINTER(BNTagType)
TagTypeTypeEnum = ctypes.c_int
class BNTemporaryFile(ctypes.Structure):
pass
BNTemporaryFileHandle = ctypes.POINTER(BNTemporaryFile)
ThemeColorEnum = ctypes.c_int
TokenEscapingTypeEnum = ctypes.c_int
class BNTransform(ctypes.Structure):
pass
BNTransformHandle = ctypes.POINTER(BNTransform)
class BNTransformParameter(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNTransformParameterHandle = ctypes.POINTER(BNTransformParameter)
class BNTransformParameterInfo(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
@property
def longName(self):
return pyNativeStr(self._longName)
@longName.setter
def longName(self, value):
self._longName = cstr(value)
BNTransformParameterInfoHandle = ctypes.POINTER(BNTransformParameterInfo)
TransformTypeEnum = ctypes.c_int
class BNType(ctypes.Structure):
pass
BNTypeHandle = ctypes.POINTER(BNType)
class BNTypeArchive(ctypes.Structure):
pass
BNTypeArchiveHandle = ctypes.POINTER(BNTypeArchive)
class BNTypeArchiveNotification(ctypes.Structure):
pass
BNTypeArchiveNotificationHandle = ctypes.POINTER(BNTypeArchiveNotification)
class BNTypeBuilder(ctypes.Structure):
pass
BNTypeBuilderHandle = ctypes.POINTER(BNTypeBuilder)
TypeClassEnum = ctypes.c_int
class BNTypeContainer(ctypes.Structure):
pass
BNTypeContainerHandle = ctypes.POINTER(BNTypeContainer)
TypeContainerTypeEnum = ctypes.c_int
class BNTypeContext(ctypes.Structure):
pass
BNTypeContextHandle = ctypes.POINTER(BNTypeContext)
class BNTypeDefinitionLine(ctypes.Structure):
@property
def rootTypeName(self):
return pyNativeStr(self._rootTypeName)
@rootTypeName.setter
def rootTypeName(self, value):
self._rootTypeName = cstr(value)
BNTypeDefinitionLineHandle = ctypes.POINTER(BNTypeDefinitionLine)
TypeDefinitionLineTypeEnum = ctypes.c_int
class BNTypeField(ctypes.Structure):
pass
BNTypeFieldHandle = ctypes.POINTER(BNTypeField)
class BNTypeFieldReference(ctypes.Structure):
pass
BNTypeFieldReferenceHandle = ctypes.POINTER(BNTypeFieldReference)
class BNTypeFieldReferenceSizeInfo(ctypes.Structure):
pass
BNTypeFieldReferenceSizeInfoHandle = ctypes.POINTER(BNTypeFieldReferenceSizeInfo)
class BNTypeFieldReferenceTypeInfo(ctypes.Structure):
pass
BNTypeFieldReferenceTypeInfoHandle = ctypes.POINTER(BNTypeFieldReferenceTypeInfo)
class BNTypeLibrary(ctypes.Structure):
pass
BNTypeLibraryHandle = ctypes.POINTER(BNTypeLibrary)
class BNTypeLibraryMapping(ctypes.Structure):
pass
BNTypeLibraryMappingHandle = ctypes.POINTER(BNTypeLibraryMapping)
class BNTypeParser(ctypes.Structure):
pass
BNTypeParserHandle = ctypes.POINTER(BNTypeParser)
class BNTypeParserCallbacks(ctypes.Structure):
pass
BNTypeParserCallbacksHandle = ctypes.POINTER(BNTypeParserCallbacks)
class BNTypeParserError(ctypes.Structure):
@property
def message(self):
return pyNativeStr(self._message)
@message.setter
def message(self, value):
self._message = cstr(value)
@property
def fileName(self):
return pyNativeStr(self._fileName)
@fileName.setter
def fileName(self, value):
self._fileName = cstr(value)
BNTypeParserErrorHandle = ctypes.POINTER(BNTypeParserError)
TypeParserErrorSeverityEnum = ctypes.c_int
TypeParserOptionEnum = ctypes.c_int
class BNTypeParserResult(ctypes.Structure):
pass
BNTypeParserResultHandle = ctypes.POINTER(BNTypeParserResult)
class BNTypePrinter(ctypes.Structure):
pass
BNTypePrinterHandle = ctypes.POINTER(BNTypePrinter)
class BNTypePrinterCallbacks(ctypes.Structure):
pass
BNTypePrinterCallbacksHandle = ctypes.POINTER(BNTypePrinterCallbacks)
class BNTypeReferenceSource(ctypes.Structure):
pass
BNTypeReferenceSourceHandle = ctypes.POINTER(BNTypeReferenceSource)
TypeReferenceTypeEnum = ctypes.c_int
class BNTypeWithConfidence(ctypes.Structure):
pass
BNTypeWithConfidenceHandle = ctypes.POINTER(BNTypeWithConfidence)
class BNUndoAction(ctypes.Structure):
@property
def summaryText(self):
return pyNativeStr(self._summaryText)
@summaryText.setter
def summaryText(self, value):
self._summaryText = cstr(value)
BNUndoActionHandle = ctypes.POINTER(BNUndoAction)
class BNUndoEntry(ctypes.Structure):
@property
def id(self):
return pyNativeStr(self._id)
@id.setter
def id(self, value):
self._id = cstr(value)
BNUndoEntryHandle = ctypes.POINTER(BNUndoEntry)
class BNUpdateChannel(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
@property
def description(self):
return pyNativeStr(self._description)
@description.setter
def description(self, value):
self._description = cstr(value)
@property
def latestVersion(self):
return pyNativeStr(self._latestVersion)
@latestVersion.setter
def latestVersion(self, value):
self._latestVersion = cstr(value)
BNUpdateChannelHandle = ctypes.POINTER(BNUpdateChannel)
class BNUpdateChannelFullInfo(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
@property
def desc(self):
return pyNativeStr(self._desc)
@desc.setter
def desc(self, value):
self._desc = cstr(value)
@property
def latestVersion(self):
return pyNativeStr(self._latestVersion)
@latestVersion.setter
def latestVersion(self, value):
self._latestVersion = cstr(value)
BNUpdateChannelFullInfoHandle = ctypes.POINTER(BNUpdateChannelFullInfo)
UpdateResultEnum = ctypes.c_int
class BNUpdateVersion(ctypes.Structure):
@property
def version(self):
return pyNativeStr(self._version)
@version.setter
def version(self, value):
self._version = cstr(value)
@property
def notes(self):
return pyNativeStr(self._notes)
@notes.setter
def notes(self, value):
self._notes = cstr(value)
BNUpdateVersionHandle = ctypes.POINTER(BNUpdateVersion)
class BNUpdateVersionNew(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNUpdateVersionNewHandle = ctypes.POINTER(BNUpdateVersionNew)
class BNUser(ctypes.Structure):
pass
BNUserHandle = ctypes.POINTER(BNUser)
class BNUserVariableValue(ctypes.Structure):
pass
BNUserVariableValueHandle = ctypes.POINTER(BNUserVariableValue)
class BNValueRange(ctypes.Structure):
pass
BNValueRangeHandle = ctypes.POINTER(BNValueRange)
class BNVariable(ctypes.Structure):
pass
BNVariableHandle = ctypes.POINTER(BNVariable)
class BNVariableNameAndType(ctypes.Structure):
@property
def name(self):
return pyNativeStr(self._name)
@name.setter
def name(self, value):
self._name = cstr(value)
BNVariableNameAndTypeHandle = ctypes.POINTER(BNVariableNameAndType)
class BNVariableReferenceSource(ctypes.Structure):
pass
BNVariableReferenceSourceHandle = ctypes.POINTER(BNVariableReferenceSource)
VariableSourceTypeEnum = ctypes.c_int
class BNVersionInfo(ctypes.Structure):
@property
def channel(self):
return pyNativeStr(self._channel)
@channel.setter
def channel(self, value):
self._channel = cstr(value)
BNVersionInfoHandle = ctypes.POINTER(BNVersionInfo)
class BNWebsocketClient(ctypes.Structure):
pass
BNWebsocketClientHandle = ctypes.POINTER(BNWebsocketClient)
class BNWebsocketClientCallbacks(ctypes.Structure):
pass
BNWebsocketClientCallbacksHandle = ctypes.POINTER(BNWebsocketClientCallbacks)
class BNWebsocketClientOutputCallbacks(ctypes.Structure):
pass
BNWebsocketClientOutputCallbacksHandle = ctypes.POINTER(BNWebsocketClientOutputCallbacks)
class BNWebsocketProvider(ctypes.Structure):
pass
BNWebsocketProviderHandle = ctypes.POINTER(BNWebsocketProvider)
class BNWebsocketProviderCallbacks(ctypes.Structure):
pass
BNWebsocketProviderCallbacksHandle = ctypes.POINTER(BNWebsocketProviderCallbacks)
class BNWorkflow(ctypes.Structure):
pass
BNWorkflowHandle = ctypes.POINTER(BNWorkflow)
PluginLoadStatusEnum = ctypes.c_int
# Structure definitions
BNActiveAnalysisInfo._fields_ = [
("func", ctypes.POINTER(BNFunction)),
("analysisTime", ctypes.c_ulonglong),
("updateCount", ctypes.c_ulonglong),
("submitCount", ctypes.c_ulonglong),
]
BNAddressRange._fields_ = [
("start", ctypes.c_ulonglong),
("end", ctypes.c_ulonglong),
]
BNAnalysisInfo._fields_ = [
("state", AnalysisStateEnum),
("analysisTime", ctypes.c_ulonglong),
("activeInfo", ctypes.POINTER(BNActiveAnalysisInfo)),
("count", ctypes.c_ulonglong),
]
BNAnalysisParameters._fields_ = [
("maxAnalysisTime", ctypes.c_ulonglong),
("maxFunctionSize", ctypes.c_ulonglong),
("maxFunctionAnalysisTime", ctypes.c_ulonglong),
("maxFunctionUpdateCount", ctypes.c_ulonglong),
("maxFunctionSubmitCount", ctypes.c_ulonglong),
("suppressNewAutoFunctionAnalysis", ctypes.c_bool),
("mode", AnalysisModeEnum),
("alwaysAnalyzeIndirectBranches", ctypes.c_bool),
("advancedAnalysisCacheSize", ctypes.c_ulonglong),
]
BNAnalysisProgress._fields_ = [
("state", AnalysisStateEnum),
("count", ctypes.c_ulonglong),
("total", ctypes.c_ulonglong),
]
BNArchitectureAndAddress._fields_ = [
("arch", ctypes.POINTER(BNArchitecture)),
("address", ctypes.c_ulonglong),
]
BNBaseStructure._fields_ = [
("type", ctypes.POINTER(BNNamedTypeReference)),
("offset", ctypes.c_ulonglong),
("width", ctypes.c_ulonglong),
]
BNBasicBlockEdge._fields_ = [
("type", BranchTypeEnum),
("target", ctypes.POINTER(BNBasicBlock)),
("backEdge", ctypes.c_bool),
("fallThrough", ctypes.c_bool),
]
BNBinaryDataNotification._fields_ = [
("context", ctypes.c_void_p),
("notificationBarrier", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("dataWritten", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("dataInserted", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("dataRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("functionAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
("functionRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
("functionUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
("functionUpdateRequested", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
("dataVariableAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNDataVariable))),
("dataVariableRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNDataVariable))),
("dataVariableUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNDataVariable))),
("dataMetadataUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
("tagTypeUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagType))),
("tagAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagReference))),
("tagRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagReference))),
("tagUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTagReference))),
("symbolAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSymbol))),
("symbolRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSymbol))),
("symbolUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSymbol))),
("stringFound", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), StringTypeEnum, ctypes.c_ulonglong, ctypes.c_ulonglong)),
("stringRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), StringTypeEnum, ctypes.c_ulonglong, ctypes.c_ulonglong)),
("typeDefined", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNType))),
("typeUndefined", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNType))),
("typeReferenceChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNType))),
("typeFieldReferenceChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNQualifiedName), ctypes.c_ulonglong)),
("segmentAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSegment))),
("segmentRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSegment))),
("segmentUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSegment))),
("sectionAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSection))),
("sectionRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSection))),
("sectionUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNSection))),
("componentNameUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.POINTER(BNComponent))),
("componentAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent))),
("componentMoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNComponent), ctypes.POINTER(BNComponent))),
("componentRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNComponent))),
("componentFunctionAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNFunction))),
("componentFunctionRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNFunction))),
("componentDataVariableAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNDataVariable))),
("componentDataVariableRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNComponent), ctypes.POINTER(BNDataVariable))),
("externalLibraryAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLibrary))),
("externalLibraryUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLibrary))),
("externalLibraryRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLibrary))),
("externalLocationAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLocation))),
("externalLocationUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLocation))),
("externalLocationRemoved", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNExternalLocation))),
("typeArchiveAttached", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p)),
("typeArchiveDetached", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p)),
("typeArchiveConnected", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTypeArchive))),
("typeArchiveDisconnected", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNTypeArchive))),
]
BNBinaryViewEvent._fields_ = [
("type", BinaryViewEventTypeEnum),
("callback", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("ctx", ctypes.c_void_p),
]
BNBoolWithConfidence._fields_ = [
("value", ctypes.c_bool),
("confidence", ctypes.c_ubyte),
]
BNCallingConventionWithConfidence._fields_ = [
("convention", ctypes.POINTER(BNCallingConvention)),
("confidence", ctypes.c_ubyte),
]
BNConstantReference._fields_ = [
("value", ctypes.c_longlong),
("size", ctypes.c_ulonglong),
("pointer", ctypes.c_bool),
("intermediate", ctypes.c_bool),
]
BNCustomArchitecture._fields_ = [
("context", ctypes.c_void_p),
("init", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNArchitecture))),
("getEndianness", ctypes.CFUNCTYPE(EndiannessEnum, ctypes.c_void_p)),
("getAddressSize", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("getDefaultIntegerSize", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("getInstructionAlignment", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("getMaxInstructionLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("getOpcodeDisplayLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("getAssociatedArchitectureByAddress", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getInstructionInfo", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.POINTER(BNInstructionInfo))),
("getInstructionText", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ulonglong), ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
("freeInstructionText", ctypes.CFUNCTYPE(None, ctypes.POINTER(BNInstructionTextToken), ctypes.c_ulonglong)),
("getInstructionLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ulonglong), ctypes.POINTER(BNLowLevelILFunction))),
("getRegisterName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
("getFlagName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
("getFlagWriteTypeName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
("getSemanticFlagClassName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
("getSemanticFlagGroupName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
("getFullWidthRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getAllRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getAllFlags", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getAllFlagWriteTypes", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getAllSemanticFlagClasses", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getAllSemanticFlagGroups", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getFlagRole", ctypes.CFUNCTYPE(FlagRoleEnum, ctypes.c_void_p, ctypes.c_uint, ctypes.c_uint)),
("getFlagsRequiredForFlagCondition", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, LowLevelILFlagConditionEnum, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
("getFlagsRequiredForSemanticFlagGroup", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
("getFlagConditionsForSemanticFlagGroup", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
("freeFlagConditionsForSemanticFlagGroup", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFlagConditionForSemanticClass))),
("getFlagsWrittenByFlagWriteType", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
("getSemanticClassForFlagWriteType", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p, ctypes.c_uint)),
("getFlagWriteLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, LowLevelILOperationEnum, ctypes.c_ulonglong, ctypes.c_uint, ctypes.c_uint, ctypes.POINTER(BNRegisterOrConstant), ctypes.c_ulonglong, ctypes.POINTER(BNLowLevelILFunction))),
("getFlagConditionLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, LowLevelILFlagConditionEnum, ctypes.c_uint, ctypes.POINTER(BNLowLevelILFunction))),
("getSemanticFlagGroupLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNLowLevelILFunction))),
("freeRegisterList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint))),
("getRegisterInfo", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNRegisterInfo))),
("getStackPointerRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
("getLinkRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
("getGlobalRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getSystemRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getRegisterStackName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
("getAllRegisterStacks", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getRegisterStackInfo", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNRegisterStackInfo))),
("getIntrinsicClass", ctypes.CFUNCTYPE(IntrinsicClassEnum, ctypes.c_void_p, ctypes.c_uint)),
("getIntrinsicName", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint)),
("getAllIntrinsics", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getIntrinsicInputs", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
("freeNameAndTypeList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNNameAndType), ctypes.c_ulonglong)),
("getIntrinsicOutputs", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(ctypes.c_ulonglong))),
("freeTypeList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeWithConfidence), ctypes.c_ulonglong)),
("canAssemble", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("assemble", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer), ctypes.POINTER(ctypes.c_char_p))),
("isNeverBranchPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("isAlwaysBranchPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("isInvertBranchPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("isSkipAndReturnZeroPatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("isSkipAndReturnValuePatchAvailable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("convertToNop", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("alwaysBranch", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("invertBranch", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("skipAndReturnValue", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.c_ulonglong)),
]
BNCustomBinaryView._fields_ = [
("context", ctypes.c_void_p),
("init", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("externalRefTaken", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("externalRefReleased", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("read", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
("write", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
("insert", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
("remove", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
("getModification", ctypes.CFUNCTYPE(ModificationStatusEnum, ctypes.c_void_p, ctypes.c_ulonglong)),
("isValidOffset", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
("isOffsetReadable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
("isOffsetWritable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
("isOffsetExecutable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
("isOffsetBackedByFile", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong)),
("getNextValidOffset", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
("getStart", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("getLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("getEntryPoint", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("isExecutable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("getDefaultEndianness", ctypes.CFUNCTYPE(EndiannessEnum, ctypes.c_void_p)),
("isRelocatable", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("getAddressSize", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("save", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNFileAccessor))),
]
BNCustomBinaryViewType._fields_ = [
("context", ctypes.c_void_p),
("create", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("parse", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("isValidForData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("isDeprecated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("getLoadSettingsForData", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
]
BNCustomCallingConvention._fields_ = [
("context", ctypes.c_void_p),
("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("getCallerSavedRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getCalleeSavedRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getIntegerArgumentRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getFloatArgumentRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("freeRegisterList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint))),
("areArgumentRegistersSharedIndex", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("isStackReservedForArgumentRegisters", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("isStackAdjustedOnReturn", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("isEligibleForHeuristics", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("getIntegerReturnValueRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
("getHighIntegerReturnValueRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
("getFloatReturnValueRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
("getGlobalPointerRegister", ctypes.CFUNCTYPE(ctypes.c_uint, ctypes.c_void_p)),
("getImplicitlyDefinedRegisters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("getIncomingRegisterValue", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNFunction), ctypes.POINTER(BNRegisterValue))),
("getIncomingFlagValue", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_uint, ctypes.POINTER(BNFunction), ctypes.POINTER(BNRegisterValue))),
("getIncomingVariableForParameterVariable", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNVariable), ctypes.POINTER(BNFunction), ctypes.POINTER(BNVariable))),
("getParameterVariableForIncomingVariable", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNVariable), ctypes.POINTER(BNFunction), ctypes.POINTER(BNVariable))),
("areArgumentRegistersUsedForVarArgs", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
]
BNCustomDataRenderer._fields_ = [
("context", ctypes.c_void_p),
("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("isValidForData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.POINTER(BNType), ctypes.POINTER(BNTypeContext), ctypes.c_ulonglong)),
("getLinesForData", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.POINTER(BNType), ctypes.POINTER(BNInstructionTextToken), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ulonglong), ctypes.POINTER(BNTypeContext), ctypes.c_ulonglong)),
("freeLines", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNDisassemblyTextLine), ctypes.c_ulonglong)),
]
BNCustomFlowGraph._fields_ = [
("context", ctypes.c_void_p),
("prepareForLayout", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("populateNodes", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("completeLayout", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("update", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("externalRefTaken", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("externalRefReleased", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
]
BNCustomRelocationHandler._fields_ = [
("context", ctypes.c_void_p),
("freeObject", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("getRelocationInfo", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNArchitecture), ctypes.POINTER(BNRelocationInfo), ctypes.c_ulonglong)),
("applyRelocation", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNArchitecture), ctypes.POINTER(BNRelocation), ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong)),
("getOperandForExternalRelocation", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_ulonglong, ctypes.POINTER(BNLowLevelILFunction), ctypes.POINTER(BNRelocation))),
]
BNCustomTransform._fields_ = [
("context", ctypes.c_void_p),
("getParameters", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong))),
("freeParameters", ctypes.CFUNCTYPE(None, ctypes.POINTER(BNTransformParameterInfo), ctypes.c_ulonglong)),
("decode", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNTransformParameter), ctypes.c_ulonglong)),
("encode", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNDataBuffer), ctypes.POINTER(BNTransformParameter), ctypes.c_ulonglong)),
]
BNDataVariable._fields_ = [
("address", ctypes.c_ulonglong),
("type", ctypes.POINTER(BNType)),
("autoDiscovered", ctypes.c_bool),
("typeConfidence", ctypes.c_ubyte),
]
BNDataVariableAndName._fields_ = [
("address", ctypes.c_ulonglong),
("type", ctypes.POINTER(BNType)),
("_name", ctypes.c_char_p),
("autoDiscovered", ctypes.c_bool),
("typeConfidence", ctypes.c_ubyte),
]
BNDataVariableAndNameAndDebugParser._fields_ = [
("address", ctypes.c_ulonglong),
("type", ctypes.POINTER(BNType)),
("_name", ctypes.c_char_p),
("_parser", ctypes.c_char_p),
("autoDiscovered", ctypes.c_bool),
("typeConfidence", ctypes.c_ubyte),
]
BNDebugFunctionInfo._fields_ = [
("_shortName", ctypes.c_char_p),
("_fullName", ctypes.c_char_p),
("_rawName", ctypes.c_char_p),
("address", ctypes.c_ulonglong),
("type", ctypes.POINTER(BNType)),
("platform", ctypes.POINTER(BNPlatform)),
("components", ctypes.POINTER(ctypes.c_char_p)),
("componentN", ctypes.c_ulonglong),
]
BNDisassemblyTextLineTypeInfo._fields_ = [
("hasTypeInfo", ctypes.c_bool),
("parentType", ctypes.POINTER(BNType)),
("fieldIndex", ctypes.c_ulonglong),
("offset", ctypes.c_ulonglong),
]
BNDownloadInstanceCallbacks._fields_ = [
("context", ctypes.c_void_p),
("destroyInstance", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("performRequest", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_char_p)),
("performCustomRequest", ctypes.CFUNCTYPE(ctypes.c_int, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.POINTER(BNDownloadInstanceResponse)))),
("freeResponse", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNDownloadInstanceResponse))),
]
BNDownloadInstanceInputOutputCallbacks._fields_ = [
("readCallback", ctypes.CFUNCTYPE(ctypes.c_longlong, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
("readContext", ctypes.c_void_p),
("writeCallback", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
("writeContext", ctypes.c_void_p),
("progressCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
("progressContext", ctypes.c_void_p),
]
BNDownloadInstanceOutputCallbacks._fields_ = [
("writeCallback", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
("writeContext", ctypes.c_void_p),
("progressCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
("progressContext", ctypes.c_void_p),
]
BNDownloadInstanceResponse._fields_ = [
("statusCode", ctypes.c_ushort),
("headerCount", ctypes.c_ulonglong),
("headerKeys", ctypes.POINTER(ctypes.c_char_p)),
("headerValues", ctypes.POINTER(ctypes.c_char_p)),
]
BNDownloadProviderCallbacks._fields_ = [
("context", ctypes.c_void_p),
("createInstance", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
]
BNEdgeStyle._fields_ = [
("style", EdgePenStyleEnum),
("width", ctypes.c_ulonglong),
("color", ThemeColorEnum),
]
BNEnterpriseServerCallbacks._fields_ = [
("context", ctypes.c_void_p),
("licenseStatusChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_bool)),
]
BNEnumerationMember._fields_ = [
("_name", ctypes.c_char_p),
("value", ctypes.c_ulonglong),
("isDefault", ctypes.c_bool),
]
BNFileAccessor._fields_ = [
("context", ctypes.c_void_p),
("getLength", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("read", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
("write", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_void_p, ctypes.c_ulonglong)),
]
BNFlagConditionForSemanticClass._fields_ = [
("semanticClass", ctypes.c_uint),
("condition", LowLevelILFlagConditionEnum),
]
BNFlowGraphEdge._fields_ = [
("type", BranchTypeEnum),
("target", ctypes.POINTER(BNFlowGraphNode)),
("points", ctypes.POINTER(BNPoint)),
("pointCount", ctypes.c_ulonglong),
("backEdge", ctypes.c_bool),
("style", BNEdgeStyle),
]
BNFormInputField._fields_ = [
("type", FormInputFieldTypeEnum),
("_prompt", ctypes.c_char_p),
("view", ctypes.POINTER(BNBinaryView)),
("currentAddress", ctypes.c_ulonglong),
("choices", ctypes.POINTER(ctypes.c_char_p)),
("count", ctypes.c_ulonglong),
("_ext", ctypes.c_char_p),
("_defaultName", ctypes.c_char_p),
("intResult", ctypes.c_longlong),
("addressResult", ctypes.c_ulonglong),
("_stringResult", ctypes.c_char_p),
("indexResult", ctypes.c_ulonglong),
("hasDefault", ctypes.c_bool),
("intDefault", ctypes.c_longlong),
("addressDefault", ctypes.c_ulonglong),
("_stringDefault", ctypes.c_char_p),
("indexDefault", ctypes.c_ulonglong),
]
BNFunctionRecognizer._fields_ = [
("context", ctypes.c_void_p),
("recognizeLowLevelIL", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction), ctypes.POINTER(BNLowLevelILFunction))),
("recognizeMediumLevelIL", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction), ctypes.POINTER(BNMediumLevelILFunction))),
]
BNHighLevelILInstruction._fields_ = [
("operation", HighLevelILOperationEnum),
("attributes", ctypes.c_uint),
("sourceOperand", ctypes.c_uint),
("size", ctypes.c_ulonglong),
("operands", ctypes.c_ulonglong * 5),
("address", ctypes.c_ulonglong),
("parent", ctypes.c_ulonglong),
]
BNHighlightColor._fields_ = [
("style", HighlightColorStyleEnum),
("color", HighlightStandardColorEnum),
("mixColor", HighlightStandardColorEnum),
("mix", ctypes.c_ubyte),
("r", ctypes.c_ubyte),
("g", ctypes.c_ubyte),
("b", ctypes.c_ubyte),
("alpha", ctypes.c_ubyte),
]
BNILBranchInstructionAndDependence._fields_ = [
("branch", ctypes.c_ulonglong),
("dependence", ILBranchDependenceEnum),
]
BNILIndexRange._fields_ = [
("start", ctypes.c_ulonglong),
("end", ctypes.c_ulonglong),
]
BNILReferenceSource._fields_ = [
("func", ctypes.POINTER(BNFunction)),
("arch", ctypes.POINTER(BNArchitecture)),
("addr", ctypes.c_ulonglong),
("type", FunctionGraphTypeEnum),
("exprId", ctypes.c_ulonglong),
]
BNIndirectBranchInfo._fields_ = [
("sourceArch", ctypes.POINTER(BNArchitecture)),
("sourceAddr", ctypes.c_ulonglong),
("destArch", ctypes.POINTER(BNArchitecture)),
("destAddr", ctypes.c_ulonglong),
("autoDefined", ctypes.c_bool),
]
BNInstructionInfo._fields_ = [
("length", ctypes.c_ulonglong),
("branchCount", ctypes.c_ulonglong),
("archTransitionByTargetAddr", ctypes.c_bool),
("branchDelay", ctypes.c_bool),
("branchType", BranchTypeEnum * 3),
("branchTarget", ctypes.c_ulonglong * 3),
("branchArch", ctypes.POINTER(BNArchitecture) * 3),
]
BNInstructionTextLine._fields_ = [
("tokens", ctypes.POINTER(BNInstructionTextToken)),
("count", ctypes.c_ulonglong),
]
BNInstructionTextToken._fields_ = [
("type", InstructionTextTokenTypeEnum),
("_text", ctypes.c_char_p),
("value", ctypes.c_ulonglong),
("width", ctypes.c_ulonglong),
("size", ctypes.c_ulonglong),
("operand", ctypes.c_ulonglong),
("context", InstructionTextTokenContextEnum),
("confidence", ctypes.c_ubyte),
("address", ctypes.c_ulonglong),
("typeNames", ctypes.POINTER(ctypes.c_char_p)),
("namesCount", ctypes.c_ulonglong),
("exprIndex", ctypes.c_ulonglong),
]
BNInteractionHandlerCallbacks._fields_ = [
("context", ctypes.c_void_p),
("showPlainTextReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p)),
("showMarkdownReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p)),
("showHTMLReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p)),
("showGraphReport", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_char_p, ctypes.POINTER(BNFlowGraph))),
("showReportCollection", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(BNReportCollection))),
("getTextLineInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p)),
("getIntegerInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_longlong), ctypes.c_char_p, ctypes.c_char_p)),
("getAddressInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong), ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
("getChoiceInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong), ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong)),
("getLargeChoiceInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ulonglong), ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong)),
("getOpenFileNameInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p)),
("getSaveFileNameInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p)),
("getDirectoryNameInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(ctypes.c_char_p), ctypes.c_char_p, ctypes.c_char_p)),
("getFormInput", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNFormInputField), ctypes.c_ulonglong, ctypes.c_char_p)),
("showMessageBox", ctypes.CFUNCTYPE(MessageBoxButtonResultEnum, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, MessageBoxButtonSetEnum, MessageBoxIconEnum)),
("openUrl", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
("runProgressDialog", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_bool, ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p), ctypes.c_void_p)),
]
BNLinearViewObjectIdentifier._fields_ = [
("_name", ctypes.c_char_p),
("type", LinearViewObjectIdentifierTypeEnum),
("start", ctypes.c_ulonglong),
("end", ctypes.c_ulonglong),
]
BNLogListener._fields_ = [
("context", ctypes.c_void_p),
("log", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong, LogLevelEnum, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_ulonglong)),
("close", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("getLogLevel", ctypes.CFUNCTYPE(LogLevelEnum, ctypes.c_void_p)),
]
BNLookupTableEntry._fields_ = [
("fromValues", ctypes.POINTER(ctypes.c_longlong)),
("fromCount", ctypes.c_ulonglong),
("toValue", ctypes.c_longlong),
]
BNLowLevelILInstruction._fields_ = [
("operation", LowLevelILOperationEnum),
("attributes", ctypes.c_uint),
("size", ctypes.c_ulonglong),
("flags", ctypes.c_uint),
("sourceOperand", ctypes.c_uint),
("operands", ctypes.c_ulonglong * 4),
("address", ctypes.c_ulonglong),
]
BNLowLevelILLabel._fields_ = [
("resolved", ctypes.c_bool),
("ref", ctypes.c_ulonglong),
("operand", ctypes.c_ulonglong),
]
BNMainThreadCallbacks._fields_ = [
("context", ctypes.c_void_p),
("addAction", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNMainThreadAction))),
]
BNMediumLevelILInstruction._fields_ = [
("operation", MediumLevelILOperationEnum),
("attributes", ctypes.c_uint),
("sourceOperand", ctypes.c_uint),
("size", ctypes.c_ulonglong),
("operands", ctypes.c_ulonglong * 5),
("address", ctypes.c_ulonglong),
]
BNMediumLevelILLabel._fields_ = [
("resolved", ctypes.c_bool),
("ref", ctypes.c_ulonglong),
("operand", ctypes.c_ulonglong),
]
BNMemoryUsageInfo._fields_ = [
("_name", ctypes.c_char_p),
("value", ctypes.c_ulonglong),
]
BNMetadataValueStore._fields_ = [
("size", ctypes.c_ulonglong),
("keys", ctypes.POINTER(ctypes.c_char_p)),
("values", ctypes.POINTER(ctypes.POINTER(BNMetadata))),
]
BNNameAndType._fields_ = [
("_name", ctypes.c_char_p),
("type", ctypes.POINTER(BNType)),
("typeConfidence", ctypes.c_ubyte),
]
BNNameList._fields_ = [
("name", ctypes.POINTER(ctypes.c_char_p)),
("_join", ctypes.c_char_p),
("nameCount", ctypes.c_ulonglong),
]
BNNameSpace._fields_ = [
("name", ctypes.POINTER(ctypes.c_char_p)),
("_join", ctypes.c_char_p),
("nameCount", ctypes.c_ulonglong),
]
BNNavigationHandler._fields_ = [
("context", ctypes.c_void_p),
("getCurrentView", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
("getCurrentOffset", ctypes.CFUNCTYPE(ctypes.c_ulonglong, ctypes.c_void_p)),
("navigate", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong)),
]
BNObjectDestructionCallbacks._fields_ = [
("context", ctypes.c_void_p),
("destructBinaryView", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("destructFileMetadata", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFileMetadata))),
("destructFunction", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFunction))),
]
BNOffsetWithConfidence._fields_ = [
("value", ctypes.c_longlong),
("confidence", ctypes.c_ubyte),
]
BNParameterVariablesWithConfidence._fields_ = [
("vars", ctypes.POINTER(BNVariable)),
("count", ctypes.c_ulonglong),
("confidence", ctypes.c_ubyte),
]
BNPerformanceInfo._fields_ = [
("_name", ctypes.c_char_p),
("seconds", ctypes.c_double),
]
BNPluginCommand._fields_ = [
("_name", ctypes.c_char_p),
("_description", ctypes.c_char_p),
("type", PluginCommandTypeEnum),
("context", ctypes.c_void_p),
("defaultCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("addressCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
("rangeCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("functionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
("lowLevelILFunctionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction))),
("lowLevelILInstructionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong)),
("mediumLevelILFunctionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction))),
("mediumLevelILInstructionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong)),
("highLevelILFunctionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction))),
("highLevelILInstructionCommand", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong)),
("defaultIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("addressIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong)),
("rangeIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong)),
("functionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction))),
("lowLevelILFunctionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction))),
("lowLevelILInstructionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong)),
("mediumLevelILFunctionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction))),
("mediumLevelILInstructionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong)),
("highLevelILFunctionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction))),
("highLevelILInstructionIsValid", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong)),
]
BNPoint._fields_ = [
("x", ctypes.c_float),
("y", ctypes.c_float),
]
BNPossibleValueSet._fields_ = [
("state", RegisterValueTypeEnum),
("value", ctypes.c_longlong),
("offset", ctypes.c_longlong),
("size", ctypes.c_ulonglong),
("ranges", ctypes.POINTER(BNValueRange)),
("valueSet", ctypes.POINTER(ctypes.c_longlong)),
("table", ctypes.POINTER(BNLookupTableEntry)),
("count", ctypes.c_ulonglong),
]
BNProjectNotification._fields_ = [
("context", ctypes.c_void_p),
("beforeOpenProject", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject))),
("afterOpenProject", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject))),
("beforeCloseProject", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject))),
("afterCloseProject", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject))),
("beforeProjectMetadataWritten", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.c_char_p, ctypes.POINTER(BNMetadata))),
("afterProjectMetadataWritten", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.c_char_p, ctypes.POINTER(BNMetadata))),
("beforeProjectFileCreated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
("afterProjectFileCreated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
("beforeProjectFileUpdated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
("afterProjectFileUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
("beforeProjectFileDeleted", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
("afterProjectFileDeleted", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFile))),
("beforeProjectFolderCreated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
("afterProjectFolderCreated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
("beforeProjectFolderUpdated", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
("afterProjectFolderUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
("beforeProjectFolderDeleted", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
("afterProjectFolderDeleted", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNProject), ctypes.POINTER(BNProjectFolder))),
]
BNQualifiedName._fields_ = [
("name", ctypes.POINTER(ctypes.c_char_p)),
("_join", ctypes.c_char_p),
("nameCount", ctypes.c_ulonglong),
]
BNQualifiedNameAndType._fields_ = [
("name", BNQualifiedName),
("type", ctypes.POINTER(BNType)),
]
BNQualifiedNameList._fields_ = [
("names", ctypes.POINTER(BNQualifiedName)),
("count", ctypes.c_ulonglong),
]
BNQualifiedNameTypeAndId._fields_ = [
("name", BNQualifiedName),
("_id", ctypes.c_char_p),
("type", ctypes.POINTER(BNType)),
]
BNRange._fields_ = [
("start", ctypes.c_ulonglong),
("end", ctypes.c_ulonglong),
]
BNReferenceSource._fields_ = [
("func", ctypes.POINTER(BNFunction)),
("arch", ctypes.POINTER(BNArchitecture)),
("addr", ctypes.c_ulonglong),
]
BNRegisterInfo._fields_ = [
("fullWidthRegister", ctypes.c_uint),
("offset", ctypes.c_ulonglong),
("size", ctypes.c_ulonglong),
("extend", ImplicitRegisterExtendEnum),
]
BNRegisterOrConstant._fields_ = [
("constant", ctypes.c_bool),
("reg", ctypes.c_uint),
("value", ctypes.c_ulonglong),
]
BNRegisterSetWithConfidence._fields_ = [
("regs", ctypes.POINTER(ctypes.c_uint)),
("count", ctypes.c_ulonglong),
("confidence", ctypes.c_ubyte),
]
BNRegisterStackAdjustment._fields_ = [
("regStack", ctypes.c_uint),
("adjustment", ctypes.c_int),
("confidence", ctypes.c_ubyte),
]
BNRegisterStackInfo._fields_ = [
("firstStorageReg", ctypes.c_uint),
("firstTopRelativeReg", ctypes.c_uint),
("storageCount", ctypes.c_uint),
("topRelativeCount", ctypes.c_uint),
("stackTopReg", ctypes.c_uint),
]
BNRegisterValue._fields_ = [
("state", RegisterValueTypeEnum),
("value", ctypes.c_longlong),
("offset", ctypes.c_longlong),
("size", ctypes.c_ulonglong),
]
BNRegisterValueWithConfidence._fields_ = [
("value", BNRegisterValue),
("confidence", ctypes.c_ubyte),
]
BNRelocationInfo._fields_ = [
("type", RelocationTypeEnum),
("pcRelative", ctypes.c_bool),
("baseRelative", ctypes.c_bool),
("base", ctypes.c_ulonglong),
("size", ctypes.c_ulonglong),
("truncateSize", ctypes.c_ulonglong),
("nativeType", ctypes.c_ulonglong),
("addend", ctypes.c_ulonglong),
("hasSign", ctypes.c_bool),
("implicitAddend", ctypes.c_bool),
("external", ctypes.c_bool),
("symbolIndex", ctypes.c_ulonglong),
("sectionIndex", ctypes.c_ulonglong),
("address", ctypes.c_ulonglong),
("target", ctypes.c_ulonglong),
("dataRelocation", ctypes.c_bool),
("relocationDataCache", ctypes.c_ubyte * 8),
("prev", ctypes.POINTER(BNRelocationInfo)),
("next", ctypes.POINTER(BNRelocationInfo)),
]
BNScriptingInstanceCallbacks._fields_ = [
("context", ctypes.c_void_p),
("destroyInstance", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("externalRefTaken", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("externalRefReleased", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("executeScriptInput", ctypes.CFUNCTYPE(ScriptingProviderExecuteResultEnum, ctypes.c_void_p, ctypes.c_char_p)),
("executeScriptInputFromFilename", ctypes.CFUNCTYPE(ScriptingProviderExecuteResultEnum, ctypes.c_void_p, ctypes.c_char_p)),
("cancelScriptInput", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("releaseBinaryView", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("setCurrentBinaryView", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView))),
("setCurrentFunction", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNFunction))),
("setCurrentBasicBlock", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBasicBlock))),
("setCurrentAddress", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong)),
("setCurrentSelection", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)),
("completeInput", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong)),
("stop", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
]
BNScriptingOutputListener._fields_ = [
("context", ctypes.c_void_p),
("output", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
("warning", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
("error", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
("inputReadyStateChanged", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ScriptingProviderInputReadyStateEnum)),
]
BNScriptingProviderCallbacks._fields_ = [
("context", ctypes.c_void_p),
("createInstance", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
("loadModule", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_bool)),
("installModules", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
]
BNSecretsProviderCallbacks._fields_ = [
("context", ctypes.c_void_p),
("hasData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
("getData", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.c_char_p)),
("storeData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p)),
("deleteData", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p)),
]
BNStackVariableReference._fields_ = [
("sourceOperand", ctypes.c_uint),
("typeConfidence", ctypes.c_ubyte),
("type", ctypes.POINTER(BNType)),
("_name", ctypes.c_char_p),
("varIdentifier", ctypes.c_ulonglong),
("referencedOffset", ctypes.c_longlong),
("size", ctypes.c_ulonglong),
]
BNStringReference._fields_ = [
("type", StringTypeEnum),
("start", ctypes.c_ulonglong),
("length", ctypes.c_ulonglong),
]
BNStructureMember._fields_ = [
("type", ctypes.POINTER(BNType)),
("_name", ctypes.c_char_p),
("offset", ctypes.c_ulonglong),
("typeConfidence", ctypes.c_ubyte),
("access", MemberAccessEnum),
("scope", MemberScopeEnum),
]
BNSystemCallInfo._fields_ = [
("number", ctypes.c_uint),
("name", BNQualifiedName),
("type", ctypes.POINTER(BNType)),
]
BNTagReference._fields_ = [
("refType", TagReferenceTypeEnum),
("autoDefined", ctypes.c_bool),
("tag", ctypes.POINTER(BNTag)),
("arch", ctypes.POINTER(BNArchitecture)),
("func", ctypes.POINTER(BNFunction)),
("addr", ctypes.c_ulonglong),
]
BNTransformParameter._fields_ = [
("_name", ctypes.c_char_p),
("value", ctypes.POINTER(BNDataBuffer)),
]
BNTransformParameterInfo._fields_ = [
("_name", ctypes.c_char_p),
("_longName", ctypes.c_char_p),
("fixedLength", ctypes.c_ulonglong),
]
BNTypeArchiveNotification._fields_ = [
("context", ctypes.c_void_p),
("typeAdded", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeArchive), ctypes.c_char_p, ctypes.POINTER(BNType))),
("typeUpdated", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeArchive), ctypes.c_char_p, ctypes.POINTER(BNType), ctypes.POINTER(BNType))),
("typeRenamed", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeArchive), ctypes.c_char_p, ctypes.POINTER(BNQualifiedName), ctypes.POINTER(BNQualifiedName))),
("typeDeleted", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeArchive), ctypes.c_char_p, ctypes.POINTER(BNType))),
]
BNTypeContext._fields_ = [
("type", ctypes.POINTER(BNType)),
("offset", ctypes.c_ulonglong),
]
BNTypeDefinitionLine._fields_ = [
("lineType", TypeDefinitionLineTypeEnum),
("tokens", ctypes.POINTER(BNInstructionTextToken)),
("count", ctypes.c_ulonglong),
("type", ctypes.POINTER(BNType)),
("parentType", ctypes.POINTER(BNType)),
("rootType", ctypes.POINTER(BNType)),
("_rootTypeName", ctypes.c_char_p),
("baseType", ctypes.POINTER(BNNamedTypeReference)),
("baseOffset", ctypes.c_ulonglong),
("offset", ctypes.c_ulonglong),
("fieldIndex", ctypes.c_ulonglong),
]
BNTypeField._fields_ = [
("name", BNQualifiedName),
("offset", ctypes.c_ulonglong),
]
BNTypeFieldReferenceSizeInfo._fields_ = [
("offset", ctypes.c_ulonglong),
("sizes", ctypes.POINTER(ctypes.c_ulonglong)),
("count", ctypes.c_ulonglong),
]
BNTypeFieldReferenceTypeInfo._fields_ = [
("offset", ctypes.c_ulonglong),
("types", ctypes.POINTER(BNTypeWithConfidence)),
("count", ctypes.c_ulonglong),
]
BNTypeParserCallbacks._fields_ = [
("context", ctypes.c_void_p),
("getOptionText", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, TypeParserOptionEnum, ctypes.c_char_p, ctypes.POINTER(ctypes.c_char_p))),
("preprocessSource", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedNameTypeAndId), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), ctypes.POINTER(ctypes.c_ulonglong))),
("parseTypesFromSource", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_char_p, ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedNameTypeAndId), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.c_ulonglong, ctypes.c_char_p, ctypes.POINTER(BNTypeParserResult), ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), ctypes.POINTER(ctypes.c_ulonglong))),
("parseTypeString", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedNameTypeAndId), ctypes.c_ulonglong, ctypes.POINTER(BNQualifiedNameAndType), ctypes.POINTER(ctypes.POINTER(BNTypeParserError)), ctypes.POINTER(ctypes.c_ulonglong))),
("freeString", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
("freeResult", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeParserResult))),
("freeErrorList", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeParserError), ctypes.c_ulonglong)),
]
BNTypeParserError._fields_ = [
("severity", TypeParserErrorSeverityEnum),
("_message", ctypes.c_char_p),
("_fileName", ctypes.c_char_p),
("line", ctypes.c_ulonglong),
("column", ctypes.c_ulonglong),
]
BNTypeParserResult._fields_ = [
("types", ctypes.POINTER(BNParsedType)),
("variables", ctypes.POINTER(BNParsedType)),
("functions", ctypes.POINTER(BNParsedType)),
("typeCount", ctypes.c_ulonglong),
("variableCount", ctypes.c_ulonglong),
("functionCount", ctypes.c_ulonglong),
]
BNTypePrinterCallbacks._fields_ = [
("context", ctypes.c_void_p),
("getTypeTokens", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedName), ctypes.c_ubyte, TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
("getTypeTokensBeforeName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.c_ubyte, ctypes.POINTER(BNType), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
("getTypeTokensAfterName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.c_ubyte, ctypes.POINTER(BNType), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)), ctypes.POINTER(ctypes.c_ulonglong))),
("getTypeString", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), ctypes.POINTER(BNQualifiedName), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
("getTypeStringBeforeName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
("getTypeStringAfterName", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNPlatform), TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
("getTypeLines", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNType), ctypes.POINTER(BNTypeContainer), ctypes.POINTER(BNQualifiedName), ctypes.c_int, ctypes.c_bool, TokenEscapingTypeEnum, ctypes.POINTER(ctypes.POINTER(BNTypeDefinitionLine)), ctypes.POINTER(ctypes.c_ulonglong))),
("printAllTypes", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNQualifiedName), ctypes.POINTER(ctypes.POINTER(BNType)), ctypes.c_ulonglong, ctypes.POINTER(BNBinaryView), ctypes.c_int, TokenEscapingTypeEnum, ctypes.POINTER(ctypes.c_char_p))),
("freeTokens", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNInstructionTextToken), ctypes.c_ulonglong)),
("freeString", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.c_char_p)),
("freeLines", ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNTypeDefinitionLine), ctypes.c_ulonglong)),
]
BNTypeReferenceSource._fields_ = [
("name", BNQualifiedName),
("offset", ctypes.c_ulonglong),
("type", TypeReferenceTypeEnum),
]
BNTypeWithConfidence._fields_ = [
("type", ctypes.POINTER(BNType)),
("confidence", ctypes.c_ubyte),
]
BNUndoAction._fields_ = [
("actionType", ActionTypeEnum),
("_summaryText", ctypes.c_char_p),
("summaryTokens", ctypes.POINTER(BNInstructionTextToken)),
("summaryTokenCount", ctypes.c_ulonglong),
]
BNUndoEntry._fields_ = [
("valid", ctypes.c_bool),
("user", ctypes.POINTER(BNUser)),
("_id", ctypes.c_char_p),
("actions", ctypes.POINTER(BNUndoAction)),
("actionCount", ctypes.c_ulonglong),
("timestamp", ctypes.c_ulonglong),
]
BNUpdateChannel._fields_ = [
("_name", ctypes.c_char_p),
("_description", ctypes.c_char_p),
("_latestVersion", ctypes.c_char_p),
]
BNUpdateChannelFullInfo._fields_ = [
("versions", ctypes.POINTER(BNUpdateVersionNew)),
("versionCount", ctypes.c_ulonglong),
("changelogEntries", ctypes.POINTER(BNChangelogEntry)),
("changelogEntryCount", ctypes.c_ulonglong),
("_name", ctypes.c_char_p),
("_desc", ctypes.c_char_p),
("_latestVersion", ctypes.c_char_p),
]
BNUpdateVersion._fields_ = [
("_version", ctypes.c_char_p),
("_notes", ctypes.c_char_p),
("time", ctypes.c_ulonglong),
]
BNValueRange._fields_ = [
("start", ctypes.c_ulonglong),
("end", ctypes.c_ulonglong),
("step", ctypes.c_ulonglong),
]
BNVariable._fields_ = [
("type", VariableSourceTypeEnum),
("index", ctypes.c_uint),
("storage", ctypes.c_longlong),
]
BNVariableNameAndType._fields_ = [
("var", BNVariable),
("type", ctypes.POINTER(BNType)),
("_name", ctypes.c_char_p),
("autoDefined", ctypes.c_bool),
("typeConfidence", ctypes.c_ubyte),
]
BNVariableReferenceSource._fields_ = [
("var", BNVariable),
("source", BNILReferenceSource),
]
BNVersionInfo._fields_ = [
("major", ctypes.c_uint),
("minor", ctypes.c_uint),
("build", ctypes.c_uint),
("_channel", ctypes.c_char_p),
]
BNWebsocketClientCallbacks._fields_ = [
("context", ctypes.c_void_p),
("destroyClient", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("connect", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p, ctypes.c_ulonglong, ctypes.POINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.c_char_p))),
("write", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
("disconnect", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
]
BNWebsocketClientOutputCallbacks._fields_ = [
("context", ctypes.c_void_p),
("connectedCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p)),
("disconnectedCallback", ctypes.CFUNCTYPE(None, ctypes.c_void_p)),
("errorCallback", ctypes.CFUNCTYPE(None, ctypes.c_char_p, ctypes.c_void_p)),
("readCallback", ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_ulonglong, ctypes.c_void_p)),
]
BNWebsocketProviderCallbacks._fields_ = [
("context", ctypes.c_void_p),
("createClient", ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p)),
]
BNChangelogEntry._fields_ = [
("version", BNVersionInfo),
("_notes", ctypes.c_char_p),
("time", ctypes.c_ulonglong),
]
BNDisassemblyTextLine._fields_ = [
("addr", ctypes.c_ulonglong),
("instrIndex", ctypes.c_ulonglong),
("tokens", ctypes.POINTER(BNInstructionTextToken)),
("count", ctypes.c_ulonglong),
("highlight", BNHighlightColor),
("tags", ctypes.POINTER(ctypes.POINTER(BNTag))),
("tagCount", ctypes.c_ulonglong),
("typeInfo", BNDisassemblyTextLineTypeInfo),
]
BNFunctionParameter._fields_ = [
("_name", ctypes.c_char_p),
("type", ctypes.POINTER(BNType)),
("typeConfidence", ctypes.c_ubyte),
("defaultLocation", ctypes.c_bool),
("location", BNVariable),
]
BNInheritedStructureMember._fields_ = [
("base", ctypes.POINTER(BNNamedTypeReference)),
("baseOffset", ctypes.c_ulonglong),
("member", BNStructureMember),
("memberIndex", ctypes.c_ulonglong),
]
BNLinearDisassemblyLine._fields_ = [
("type", LinearDisassemblyLineTypeEnum),
("function", ctypes.POINTER(BNFunction)),
("block", ctypes.POINTER(BNBasicBlock)),
("contents", BNDisassemblyTextLine),
]
BNMergedVariable._fields_ = [
("target", BNVariable),
("sources", ctypes.POINTER(BNVariable)),
("sourceCount", ctypes.c_ulonglong),
]
BNParsedType._fields_ = [
("name", BNQualifiedName),
("type", ctypes.POINTER(BNType)),
("isUser", ctypes.c_bool),
]
BNTypeFieldReference._fields_ = [
("func", ctypes.POINTER(BNFunction)),
("arch", ctypes.POINTER(BNArchitecture)),
("addr", ctypes.c_ulonglong),
("size", ctypes.c_ulonglong),
("incomingType", BNTypeWithConfidence),
]
BNUpdateVersionNew._fields_ = [
("version", BNVersionInfo),
("_name", ctypes.c_char_p),
("time", ctypes.c_ulonglong),
]
BNUserVariableValue._fields_ = [
("var", BNVariable),
("defSite", BNArchitectureAndAddress),
("value", BNPossibleValueSet),
]
# Function definitions
# -------------------------------------------------------
# _BNAbortAnalysis
_BNAbortAnalysis = core.BNAbortAnalysis
_BNAbortAnalysis.restype = None
_BNAbortAnalysis.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNAbortAnalysis(
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNAbortAnalysis(view)
# -------------------------------------------------------
# _BNAbortFlowGraphLayoutRequest
_BNAbortFlowGraphLayoutRequest = core.BNAbortFlowGraphLayoutRequest
_BNAbortFlowGraphLayoutRequest.restype = None
_BNAbortFlowGraphLayoutRequest.argtypes = [
ctypes.POINTER(BNFlowGraphLayoutRequest),
]
# noinspection PyPep8Naming
def BNAbortFlowGraphLayoutRequest(
graph: ctypes.POINTER(BNFlowGraphLayoutRequest)
) -> None:
return _BNAbortFlowGraphLayoutRequest(graph)
# -------------------------------------------------------
# _BNActivityGetName
_BNActivityGetName = core.BNActivityGetName
_BNActivityGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNActivityGetName.argtypes = [
ctypes.POINTER(BNActivity),
]
# noinspection PyPep8Naming
def BNActivityGetName(
activity: ctypes.POINTER(BNActivity)
) -> Optional[Optional[str]]:
result = _BNActivityGetName(activity)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNAddAnalysisCompletionEvent
_BNAddAnalysisCompletionEvent = core.BNAddAnalysisCompletionEvent
_BNAddAnalysisCompletionEvent.restype = ctypes.POINTER(BNAnalysisCompletionEvent)
_BNAddAnalysisCompletionEvent.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
]
# noinspection PyPep8Naming
def BNAddAnalysisCompletionEvent(
view: ctypes.POINTER(BNBinaryView),
ctxt: Optional[ctypes.c_void_p],
callback: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
) -> Optional[ctypes.POINTER(BNAnalysisCompletionEvent)]:
result = _BNAddAnalysisCompletionEvent(view, ctxt, callback)
if not result:
return None
return result
# -------------------------------------------------------
# _BNAddAnalysisOption
_BNAddAnalysisOption = core.BNAddAnalysisOption
_BNAddAnalysisOption.restype = None
_BNAddAnalysisOption.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAddAnalysisOption(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> None:
return _BNAddAnalysisOption(view, cstr(name))
# -------------------------------------------------------
# _BNAddArchitectureRedirection
_BNAddArchitectureRedirection = core.BNAddArchitectureRedirection
_BNAddArchitectureRedirection.restype = None
_BNAddArchitectureRedirection.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNAddArchitectureRedirection(
arch: ctypes.POINTER(BNArchitecture),
from_: ctypes.POINTER(BNArchitecture),
to: ctypes.POINTER(BNArchitecture)
) -> None:
return _BNAddArchitectureRedirection(arch, from_, to)
# -------------------------------------------------------
# _BNAddAutoAddressTag
_BNAddAutoAddressTag = core.BNAddAutoAddressTag
_BNAddAutoAddressTag.restype = None
_BNAddAutoAddressTag.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNAddAutoAddressTag(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNAddAutoAddressTag(func, arch, addr, tag)
# -------------------------------------------------------
# _BNAddAutoDataTag
_BNAddAutoDataTag = core.BNAddAutoDataTag
_BNAddAutoDataTag.restype = None
_BNAddAutoDataTag.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNAddAutoDataTag(
view: ctypes.POINTER(BNBinaryView),
addr: int,
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNAddAutoDataTag(view, addr, tag)
# -------------------------------------------------------
# _BNAddAutoFunctionTag
_BNAddAutoFunctionTag = core.BNAddAutoFunctionTag
_BNAddAutoFunctionTag.restype = None
_BNAddAutoFunctionTag.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNAddAutoFunctionTag(
func: ctypes.POINTER(BNFunction),
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNAddAutoFunctionTag(func, tag)
# -------------------------------------------------------
# _BNAddAutoSection
_BNAddAutoSection = core.BNAddAutoSection
_BNAddAutoSection.restype = None
_BNAddAutoSection.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
SectionSemanticsEnum,
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddAutoSection(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str],
start: int,
length: int,
semantics: SectionSemantics,
type: Optional[str],
align: int,
entrySize: int,
linkedSection: Optional[str],
infoSection: Optional[str],
infoData: int
) -> None:
return _BNAddAutoSection(view, cstr(name), start, length, semantics, cstr(type), align, entrySize, cstr(linkedSection), cstr(infoSection), infoData)
# -------------------------------------------------------
# _BNAddAutoSegment
_BNAddAutoSegment = core.BNAddAutoSegment
_BNAddAutoSegment.restype = None
_BNAddAutoSegment.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNAddAutoSegment(
view: ctypes.POINTER(BNBinaryView),
start: int,
length: int,
dataOffset: int,
dataLength: int,
flags: int
) -> None:
return _BNAddAutoSegment(view, start, length, dataOffset, dataLength, flags)
# -------------------------------------------------------
# _BNAddBinaryViewTypeLibrary
_BNAddBinaryViewTypeLibrary = core.BNAddBinaryViewTypeLibrary
_BNAddBinaryViewTypeLibrary.restype = None
_BNAddBinaryViewTypeLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNAddBinaryViewTypeLibrary(
view: ctypes.POINTER(BNBinaryView),
lib: ctypes.POINTER(BNTypeLibrary)
) -> None:
return _BNAddBinaryViewTypeLibrary(view, lib)
# -------------------------------------------------------
# _BNAddDebugDataVariable
_BNAddDebugDataVariable = core.BNAddDebugDataVariable
_BNAddDebugDataVariable.restype = ctypes.c_bool
_BNAddDebugDataVariable.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_ulonglong,
ctypes.POINTER(BNType),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddDebugDataVariable(
debugInfo: ctypes.POINTER(BNDebugInfo),
address: int,
type: ctypes.POINTER(BNType),
name: Optional[str],
components: ctypes.POINTER(ctypes.c_char_p),
components_count: int
) -> bool:
return _BNAddDebugDataVariable(debugInfo, address, type, cstr(name), components, components_count)
# -------------------------------------------------------
# _BNAddDebugDataVariableInfo
_BNAddDebugDataVariableInfo = core.BNAddDebugDataVariableInfo
_BNAddDebugDataVariableInfo.restype = ctypes.c_bool
_BNAddDebugDataVariableInfo.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.POINTER(BNDataVariableAndName),
]
# noinspection PyPep8Naming
def BNAddDebugDataVariableInfo(
debugInfo: ctypes.POINTER(BNDebugInfo),
var: ctypes.POINTER(BNDataVariableAndName)
) -> bool:
return _BNAddDebugDataVariableInfo(debugInfo, var)
# -------------------------------------------------------
# _BNAddDebugFunction
_BNAddDebugFunction = core.BNAddDebugFunction
_BNAddDebugFunction.restype = ctypes.c_bool
_BNAddDebugFunction.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.POINTER(BNDebugFunctionInfo),
]
# noinspection PyPep8Naming
def BNAddDebugFunction(
debugInfo: ctypes.POINTER(BNDebugInfo),
func: ctypes.POINTER(BNDebugFunctionInfo)
) -> bool:
return _BNAddDebugFunction(debugInfo, func)
# -------------------------------------------------------
# _BNAddDebugType
_BNAddDebugType = core.BNAddDebugType
_BNAddDebugType.restype = ctypes.c_bool
_BNAddDebugType.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.POINTER(BNType),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddDebugType(
debugInfo: ctypes.POINTER(BNDebugInfo),
name: Optional[str],
type: ctypes.POINTER(BNType),
components: ctypes.POINTER(ctypes.c_char_p),
components_count: int
) -> bool:
return _BNAddDebugType(debugInfo, cstr(name), type, components, components_count)
# -------------------------------------------------------
# _BNAddEntryPointForAnalysis
_BNAddEntryPointForAnalysis = core.BNAddEntryPointForAnalysis
_BNAddEntryPointForAnalysis.restype = None
_BNAddEntryPointForAnalysis.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNPlatform),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddEntryPointForAnalysis(
view: ctypes.POINTER(BNBinaryView),
platform: ctypes.POINTER(BNPlatform),
addr: int
) -> None:
return _BNAddEntryPointForAnalysis(view, platform, addr)
# -------------------------------------------------------
# _BNAddEnumerationBuilderMember
_BNAddEnumerationBuilderMember = core.BNAddEnumerationBuilderMember
_BNAddEnumerationBuilderMember.restype = None
_BNAddEnumerationBuilderMember.argtypes = [
ctypes.POINTER(BNEnumerationBuilder),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAddEnumerationBuilderMember(
e: ctypes.POINTER(BNEnumerationBuilder),
name: Optional[str]
) -> None:
return _BNAddEnumerationBuilderMember(e, cstr(name))
# -------------------------------------------------------
# _BNAddEnumerationBuilderMemberWithValue
_BNAddEnumerationBuilderMemberWithValue = core.BNAddEnumerationBuilderMemberWithValue
_BNAddEnumerationBuilderMemberWithValue.restype = None
_BNAddEnumerationBuilderMemberWithValue.argtypes = [
ctypes.POINTER(BNEnumerationBuilder),
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddEnumerationBuilderMemberWithValue(
e: ctypes.POINTER(BNEnumerationBuilder),
name: Optional[str],
value: int
) -> None:
return _BNAddEnumerationBuilderMemberWithValue(e, cstr(name), value)
# -------------------------------------------------------
# _BNAddExpressionParserMagicValue
_BNAddExpressionParserMagicValue = core.BNAddExpressionParserMagicValue
_BNAddExpressionParserMagicValue.restype = None
_BNAddExpressionParserMagicValue.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddExpressionParserMagicValue(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str],
value: int
) -> None:
return _BNAddExpressionParserMagicValue(view, cstr(name), value)
# -------------------------------------------------------
# _BNAddExpressionParserMagicValues
_BNAddExpressionParserMagicValues = core.BNAddExpressionParserMagicValues
_BNAddExpressionParserMagicValues.restype = None
_BNAddExpressionParserMagicValues.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddExpressionParserMagicValues(
view: ctypes.POINTER(BNBinaryView),
names: ctypes.POINTER(ctypes.c_char_p),
values: ctypes.POINTER(ctypes.c_ulonglong),
count: int
) -> None:
return _BNAddExpressionParserMagicValues(view, names, values, count)
# -------------------------------------------------------
# _BNAddFlowGraphNode
_BNAddFlowGraphNode = core.BNAddFlowGraphNode
_BNAddFlowGraphNode.restype = ctypes.c_ulonglong
_BNAddFlowGraphNode.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNAddFlowGraphNode(
graph: ctypes.POINTER(BNFlowGraph),
node: ctypes.POINTER(BNFlowGraphNode)
) -> int:
return _BNAddFlowGraphNode(graph, node)
# -------------------------------------------------------
# _BNAddFlowGraphNodeOutgoingEdge
_BNAddFlowGraphNodeOutgoingEdge = core.BNAddFlowGraphNodeOutgoingEdge
_BNAddFlowGraphNodeOutgoingEdge.restype = None
_BNAddFlowGraphNodeOutgoingEdge.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
BranchTypeEnum,
ctypes.POINTER(BNFlowGraphNode),
BNEdgeStyle,
]
# noinspection PyPep8Naming
def BNAddFlowGraphNodeOutgoingEdge(
node: ctypes.POINTER(BNFlowGraphNode),
type: BranchType,
target: ctypes.POINTER(BNFlowGraphNode),
edgeStyle: BNEdgeStyle
) -> None:
return _BNAddFlowGraphNodeOutgoingEdge(node, type, target, edgeStyle)
# -------------------------------------------------------
# _BNAddFunctionForAnalysis
_BNAddFunctionForAnalysis = core.BNAddFunctionForAnalysis
_BNAddFunctionForAnalysis.restype = ctypes.POINTER(BNFunction)
_BNAddFunctionForAnalysis.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNPlatform),
ctypes.c_ulonglong,
ctypes.c_bool,
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNAddFunctionForAnalysis(
view: ctypes.POINTER(BNBinaryView),
platform: ctypes.POINTER(BNPlatform),
addr: int,
autoDiscovered: bool,
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNAddFunctionForAnalysis(view, platform, addr, autoDiscovered, type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNAddGraphReportToCollection
_BNAddGraphReportToCollection = core.BNAddGraphReportToCollection
_BNAddGraphReportToCollection.restype = None
_BNAddGraphReportToCollection.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNAddGraphReportToCollection(
reports: ctypes.POINTER(BNReportCollection),
view: ctypes.POINTER(BNBinaryView),
title: Optional[str],
graph: ctypes.POINTER(BNFlowGraph)
) -> None:
return _BNAddGraphReportToCollection(reports, view, cstr(title), graph)
# -------------------------------------------------------
# _BNAddHTMLReportToCollection
_BNAddHTMLReportToCollection = core.BNAddHTMLReportToCollection
_BNAddHTMLReportToCollection.restype = None
_BNAddHTMLReportToCollection.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAddHTMLReportToCollection(
reports: ctypes.POINTER(BNReportCollection),
view: ctypes.POINTER(BNBinaryView),
title: Optional[str],
contents: Optional[str],
plaintext: Optional[str]
) -> None:
return _BNAddHTMLReportToCollection(reports, view, cstr(title), cstr(contents), cstr(plaintext))
# -------------------------------------------------------
# _BNAddLowLevelILLabelForAddress
_BNAddLowLevelILLabelForAddress = core.BNAddLowLevelILLabelForAddress
_BNAddLowLevelILLabelForAddress.restype = None
_BNAddLowLevelILLabelForAddress.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddLowLevelILLabelForAddress(
func: ctypes.POINTER(BNLowLevelILFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> None:
return _BNAddLowLevelILLabelForAddress(func, arch, addr)
# -------------------------------------------------------
# _BNAddMarkdownReportToCollection
_BNAddMarkdownReportToCollection = core.BNAddMarkdownReportToCollection
_BNAddMarkdownReportToCollection.restype = None
_BNAddMarkdownReportToCollection.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAddMarkdownReportToCollection(
reports: ctypes.POINTER(BNReportCollection),
view: ctypes.POINTER(BNBinaryView),
title: Optional[str],
contents: Optional[str],
plaintext: Optional[str]
) -> None:
return _BNAddMarkdownReportToCollection(reports, view, cstr(title), cstr(contents), cstr(plaintext))
# -------------------------------------------------------
# _BNAddOptionalPluginDependency
_BNAddOptionalPluginDependency = core.BNAddOptionalPluginDependency
_BNAddOptionalPluginDependency.restype = None
_BNAddOptionalPluginDependency.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAddOptionalPluginDependency(
name: Optional[str]
) -> None:
return _BNAddOptionalPluginDependency(cstr(name))
# -------------------------------------------------------
# _BNAddPlainTextReportToCollection
_BNAddPlainTextReportToCollection = core.BNAddPlainTextReportToCollection
_BNAddPlainTextReportToCollection.restype = None
_BNAddPlainTextReportToCollection.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAddPlainTextReportToCollection(
reports: ctypes.POINTER(BNReportCollection),
view: ctypes.POINTER(BNBinaryView),
title: Optional[str],
contents: Optional[str]
) -> None:
return _BNAddPlainTextReportToCollection(reports, view, cstr(title), cstr(contents))
# -------------------------------------------------------
# _BNAddRelatedPlatform
_BNAddRelatedPlatform = core.BNAddRelatedPlatform
_BNAddRelatedPlatform.restype = None
_BNAddRelatedPlatform.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNAddRelatedPlatform(
platform: ctypes.POINTER(BNPlatform),
arch: ctypes.POINTER(BNArchitecture),
related: ctypes.POINTER(BNPlatform)
) -> None:
return _BNAddRelatedPlatform(platform, arch, related)
# -------------------------------------------------------
# _BNAddRequiredPluginDependency
_BNAddRequiredPluginDependency = core.BNAddRequiredPluginDependency
_BNAddRequiredPluginDependency.restype = None
_BNAddRequiredPluginDependency.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAddRequiredPluginDependency(
name: Optional[str]
) -> None:
return _BNAddRequiredPluginDependency(cstr(name))
# -------------------------------------------------------
# _BNAddStructureBuilderMember
_BNAddStructureBuilderMember = core.BNAddStructureBuilderMember
_BNAddStructureBuilderMember.restype = None
_BNAddStructureBuilderMember.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_char_p,
MemberAccessEnum,
MemberScopeEnum,
]
# noinspection PyPep8Naming
def BNAddStructureBuilderMember(
s: ctypes.POINTER(BNStructureBuilder),
type: ctypes.POINTER(BNTypeWithConfidence),
name: Optional[str],
access: MemberAccess,
scope: MemberScope
) -> None:
return _BNAddStructureBuilderMember(s, type, cstr(name), access, scope)
# -------------------------------------------------------
# _BNAddStructureBuilderMemberAtOffset
_BNAddStructureBuilderMemberAtOffset = core.BNAddStructureBuilderMemberAtOffset
_BNAddStructureBuilderMemberAtOffset.restype = None
_BNAddStructureBuilderMemberAtOffset.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.c_bool,
MemberAccessEnum,
MemberScopeEnum,
]
# noinspection PyPep8Naming
def BNAddStructureBuilderMemberAtOffset(
s: ctypes.POINTER(BNStructureBuilder),
type: ctypes.POINTER(BNTypeWithConfidence),
name: Optional[str],
offset: int,
overwriteExisting: bool,
access: MemberAccess,
scope: MemberScope
) -> None:
return _BNAddStructureBuilderMemberAtOffset(s, type, cstr(name), offset, overwriteExisting, access, scope)
# -------------------------------------------------------
# _BNAddTag
_BNAddTag = core.BNAddTag
_BNAddTag.restype = None
_BNAddTag.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTag),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNAddTag(
view: ctypes.POINTER(BNBinaryView),
tag: ctypes.POINTER(BNTag),
user: bool
) -> None:
return _BNAddTag(view, tag, user)
# -------------------------------------------------------
# _BNAddTagType
_BNAddTagType = core.BNAddTagType
_BNAddTagType.restype = None
_BNAddTagType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNAddTagType(
view: ctypes.POINTER(BNBinaryView),
tagType: ctypes.POINTER(BNTagType)
) -> None:
return _BNAddTagType(view, tagType)
# -------------------------------------------------------
# _BNAddTypeArchiveTypes
_BNAddTypeArchiveTypes = core.BNAddTypeArchiveTypes
_BNAddTypeArchiveTypes.restype = ctypes.c_bool
_BNAddTypeArchiveTypes.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.POINTER(BNQualifiedNameAndType),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddTypeArchiveTypes(
archive: ctypes.POINTER(BNTypeArchive),
types: ctypes.POINTER(BNQualifiedNameAndType),
count: int
) -> bool:
return _BNAddTypeArchiveTypes(archive, types, count)
# -------------------------------------------------------
# _BNAddTypeLibraryAlternateName
_BNAddTypeLibraryAlternateName = core.BNAddTypeLibraryAlternateName
_BNAddTypeLibraryAlternateName.restype = None
_BNAddTypeLibraryAlternateName.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAddTypeLibraryAlternateName(
lib: ctypes.POINTER(BNTypeLibrary),
name: Optional[str]
) -> None:
return _BNAddTypeLibraryAlternateName(lib, cstr(name))
# -------------------------------------------------------
# _BNAddTypeLibraryNamedObject
_BNAddTypeLibraryNamedObject = core.BNAddTypeLibraryNamedObject
_BNAddTypeLibraryNamedObject.restype = None
_BNAddTypeLibraryNamedObject.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNAddTypeLibraryNamedObject(
lib: ctypes.POINTER(BNTypeLibrary),
name: ctypes.POINTER(BNQualifiedName),
type: ctypes.POINTER(BNType)
) -> None:
return _BNAddTypeLibraryNamedObject(lib, name, type)
# -------------------------------------------------------
# _BNAddTypeLibraryNamedType
_BNAddTypeLibraryNamedType = core.BNAddTypeLibraryNamedType
_BNAddTypeLibraryNamedType.restype = None
_BNAddTypeLibraryNamedType.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNAddTypeLibraryNamedType(
lib: ctypes.POINTER(BNTypeLibrary),
name: ctypes.POINTER(BNQualifiedName),
type: ctypes.POINTER(BNType)
) -> None:
return _BNAddTypeLibraryNamedType(lib, name, type)
# -------------------------------------------------------
# _BNAddTypeLibraryNamedTypeSource
_BNAddTypeLibraryNamedTypeSource = core.BNAddTypeLibraryNamedTypeSource
_BNAddTypeLibraryNamedTypeSource.restype = None
_BNAddTypeLibraryNamedTypeSource.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(BNQualifiedName),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAddTypeLibraryNamedTypeSource(
lib: ctypes.POINTER(BNTypeLibrary),
name: ctypes.POINTER(BNQualifiedName),
source: Optional[str]
) -> None:
return _BNAddTypeLibraryNamedTypeSource(lib, name, cstr(source))
# -------------------------------------------------------
# _BNAddTypeLibraryPlatform
_BNAddTypeLibraryPlatform = core.BNAddTypeLibraryPlatform
_BNAddTypeLibraryPlatform.restype = None
_BNAddTypeLibraryPlatform.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNAddTypeLibraryPlatform(
lib: ctypes.POINTER(BNTypeLibrary),
platform: ctypes.POINTER(BNPlatform)
) -> None:
return _BNAddTypeLibraryPlatform(lib, platform)
# -------------------------------------------------------
# _BNAddTypeMemberTokens
_BNAddTypeMemberTokens = core.BNAddTypeMemberTokens
_BNAddTypeMemberTokens.restype = ctypes.c_bool
_BNAddTypeMemberTokens.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_longlong,
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_ulonglong,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNAddTypeMemberTokens(
type: ctypes.POINTER(BNType),
data: ctypes.POINTER(BNBinaryView),
tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
tokenCount: ctypes.POINTER(ctypes.c_ulonglong),
offset: int,
nameList: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
nameCount: ctypes.POINTER(ctypes.c_ulonglong),
size: int,
indirect: bool
) -> bool:
return _BNAddTypeMemberTokens(type, data, tokens, tokenCount, offset, nameList, nameCount, size, indirect)
# -------------------------------------------------------
# _BNAddUserAddressTag
_BNAddUserAddressTag = core.BNAddUserAddressTag
_BNAddUserAddressTag.restype = None
_BNAddUserAddressTag.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNAddUserAddressTag(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNAddUserAddressTag(func, arch, addr, tag)
# -------------------------------------------------------
# _BNAddUserCodeReference
_BNAddUserCodeReference = core.BNAddUserCodeReference
_BNAddUserCodeReference.restype = None
_BNAddUserCodeReference.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddUserCodeReference(
func: ctypes.POINTER(BNFunction),
fromArch: ctypes.POINTER(BNArchitecture),
fromAddr: int,
toAddr: int
) -> None:
return _BNAddUserCodeReference(func, fromArch, fromAddr, toAddr)
# -------------------------------------------------------
# _BNAddUserDataReference
_BNAddUserDataReference = core.BNAddUserDataReference
_BNAddUserDataReference.restype = None
_BNAddUserDataReference.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddUserDataReference(
view: ctypes.POINTER(BNBinaryView),
fromAddr: int,
toAddr: int
) -> None:
return _BNAddUserDataReference(view, fromAddr, toAddr)
# -------------------------------------------------------
# _BNAddUserDataTag
_BNAddUserDataTag = core.BNAddUserDataTag
_BNAddUserDataTag.restype = None
_BNAddUserDataTag.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNAddUserDataTag(
view: ctypes.POINTER(BNBinaryView),
addr: int,
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNAddUserDataTag(view, addr, tag)
# -------------------------------------------------------
# _BNAddUserFunctionTag
_BNAddUserFunctionTag = core.BNAddUserFunctionTag
_BNAddUserFunctionTag.restype = None
_BNAddUserFunctionTag.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNAddUserFunctionTag(
func: ctypes.POINTER(BNFunction),
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNAddUserFunctionTag(func, tag)
# -------------------------------------------------------
# _BNAddUserSection
_BNAddUserSection = core.BNAddUserSection
_BNAddUserSection.restype = None
_BNAddUserSection.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
SectionSemanticsEnum,
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddUserSection(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str],
start: int,
length: int,
semantics: SectionSemantics,
type: Optional[str],
align: int,
entrySize: int,
linkedSection: Optional[str],
infoSection: Optional[str],
infoData: int
) -> None:
return _BNAddUserSection(view, cstr(name), start, length, semantics, cstr(type), align, entrySize, cstr(linkedSection), cstr(infoSection), infoData)
# -------------------------------------------------------
# _BNAddUserSegment
_BNAddUserSegment = core.BNAddUserSegment
_BNAddUserSegment.restype = None
_BNAddUserSegment.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNAddUserSegment(
view: ctypes.POINTER(BNBinaryView),
start: int,
length: int,
dataOffset: int,
dataLength: int,
flags: int
) -> None:
return _BNAddUserSegment(view, start, length, dataOffset, dataLength, flags)
# -------------------------------------------------------
# _BNAddUserTypeFieldReference
_BNAddUserTypeFieldReference = core.BNAddUserTypeFieldReference
_BNAddUserTypeFieldReference.restype = None
_BNAddUserTypeFieldReference.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAddUserTypeFieldReference(
func: ctypes.POINTER(BNFunction),
fromArch: ctypes.POINTER(BNArchitecture),
fromAddr: int,
name: ctypes.POINTER(BNQualifiedName),
offset: int,
size: int
) -> None:
return _BNAddUserTypeFieldReference(func, fromArch, fromAddr, name, offset, size)
# -------------------------------------------------------
# _BNAddUserTypeReference
_BNAddUserTypeReference = core.BNAddUserTypeReference
_BNAddUserTypeReference.restype = None
_BNAddUserTypeReference.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNAddUserTypeReference(
func: ctypes.POINTER(BNFunction),
fromArch: ctypes.POINTER(BNArchitecture),
fromAddr: int,
name: ctypes.POINTER(BNQualifiedName)
) -> None:
return _BNAddUserTypeReference(func, fromArch, fromAddr, name)
# -------------------------------------------------------
# _BNAllocString
_BNAllocString = core.BNAllocString
_BNAllocString.restype = ctypes.c_void_p
_BNAllocString.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAllocString(
contents: Optional[str]
) -> Optional[Optional[str]]:
result = _BNAllocString(cstr(contents))
if not result:
return None
return result
# -------------------------------------------------------
# _BNAllocStringList
_BNAllocStringList = core.BNAllocStringList
_BNAllocStringList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNAllocStringList.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAllocStringList(
contents: ctypes.POINTER(ctypes.c_char_p),
size: int
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNAllocStringList(contents, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNAlwaysBranch
_BNAlwaysBranch = core.BNAlwaysBranch
_BNAlwaysBranch.restype = ctypes.c_bool
_BNAlwaysBranch.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAlwaysBranch(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> bool:
return _BNAlwaysBranch(view, arch, addr)
# -------------------------------------------------------
# _BNAnalysisContextGetFunction
_BNAnalysisContextGetFunction = core.BNAnalysisContextGetFunction
_BNAnalysisContextGetFunction.restype = ctypes.POINTER(BNFunction)
_BNAnalysisContextGetFunction.argtypes = [
ctypes.POINTER(BNAnalysisContext),
]
# noinspection PyPep8Naming
def BNAnalysisContextGetFunction(
analysisContext: ctypes.POINTER(BNAnalysisContext)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNAnalysisContextGetFunction(analysisContext)
if not result:
return None
return result
# -------------------------------------------------------
# _BNAnalysisContextGetHighLevelILFunction
_BNAnalysisContextGetHighLevelILFunction = core.BNAnalysisContextGetHighLevelILFunction
_BNAnalysisContextGetHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNAnalysisContextGetHighLevelILFunction.argtypes = [
ctypes.POINTER(BNAnalysisContext),
]
# noinspection PyPep8Naming
def BNAnalysisContextGetHighLevelILFunction(
analysisContext: ctypes.POINTER(BNAnalysisContext)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNAnalysisContextGetHighLevelILFunction(analysisContext)
if not result:
return None
return result
# -------------------------------------------------------
# _BNAnalysisContextGetLowLevelILFunction
_BNAnalysisContextGetLowLevelILFunction = core.BNAnalysisContextGetLowLevelILFunction
_BNAnalysisContextGetLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNAnalysisContextGetLowLevelILFunction.argtypes = [
ctypes.POINTER(BNAnalysisContext),
]
# noinspection PyPep8Naming
def BNAnalysisContextGetLowLevelILFunction(
analysisContext: ctypes.POINTER(BNAnalysisContext)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNAnalysisContextGetLowLevelILFunction(analysisContext)
if not result:
return None
return result
# -------------------------------------------------------
# _BNAnalysisContextGetMediumLevelILFunction
_BNAnalysisContextGetMediumLevelILFunction = core.BNAnalysisContextGetMediumLevelILFunction
_BNAnalysisContextGetMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNAnalysisContextGetMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNAnalysisContext),
]
# noinspection PyPep8Naming
def BNAnalysisContextGetMediumLevelILFunction(
analysisContext: ctypes.POINTER(BNAnalysisContext)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNAnalysisContextGetMediumLevelILFunction(analysisContext)
if not result:
return None
return result
# -------------------------------------------------------
# _BNAnalysisContextInform
_BNAnalysisContextInform = core.BNAnalysisContextInform
_BNAnalysisContextInform.restype = ctypes.c_bool
_BNAnalysisContextInform.argtypes = [
ctypes.POINTER(BNAnalysisContext),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAnalysisContextInform(
analysisContext: ctypes.POINTER(BNAnalysisContext),
request: Optional[str]
) -> bool:
return _BNAnalysisContextInform(analysisContext, cstr(request))
# -------------------------------------------------------
# _BNAppendDataBuffer
_BNAppendDataBuffer = core.BNAppendDataBuffer
_BNAppendDataBuffer.restype = None
_BNAppendDataBuffer.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNAppendDataBuffer(
dest: ctypes.POINTER(BNDataBuffer),
src: ctypes.POINTER(BNDataBuffer)
) -> None:
return _BNAppendDataBuffer(dest, src)
# -------------------------------------------------------
# _BNAppendDataBufferContents
_BNAppendDataBufferContents = core.BNAppendDataBufferContents
_BNAppendDataBufferContents.restype = None
_BNAppendDataBufferContents.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.c_void_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNAppendDataBufferContents(
dest: ctypes.POINTER(BNDataBuffer),
src: Optional[ctypes.c_void_p],
len: int
) -> None:
return _BNAppendDataBufferContents(dest, src, len)
# -------------------------------------------------------
# _BNAppendPath
_BNAppendPath = core.BNAppendPath
_BNAppendPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNAppendPath.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNAppendPath(
path: Optional[str],
part: Optional[str]
) -> Optional[Optional[str]]:
result = _BNAppendPath(cstr(path), cstr(part))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNAppendSymbolQueue
_BNAppendSymbolQueue = core.BNAppendSymbolQueue
_BNAppendSymbolQueue.restype = None
_BNAppendSymbolQueue.argtypes = [
ctypes.POINTER(BNSymbolQueue),
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.POINTER(BNSymbol)), ctypes.POINTER(ctypes.POINTER(BNType))),
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNSymbol), ctypes.POINTER(BNType)),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNAppendSymbolQueue(
queue: ctypes.POINTER(BNSymbolQueue),
resolve: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(ctypes.POINTER(BNSymbol)), ctypes.POINTER(ctypes.POINTER(BNType))),
resolveContext: Optional[ctypes.c_void_p],
add: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNSymbol), ctypes.POINTER(BNType)),
addContext: Optional[ctypes.c_void_p]
) -> None:
return _BNAppendSymbolQueue(queue, resolve, resolveContext, add, addContext)
# -------------------------------------------------------
# _BNApplyAutoDiscoveredFunctionType
_BNApplyAutoDiscoveredFunctionType = core.BNApplyAutoDiscoveredFunctionType
_BNApplyAutoDiscoveredFunctionType.restype = None
_BNApplyAutoDiscoveredFunctionType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNApplyAutoDiscoveredFunctionType(
func: ctypes.POINTER(BNFunction),
type: ctypes.POINTER(BNType)
) -> None:
return _BNApplyAutoDiscoveredFunctionType(func, type)
# -------------------------------------------------------
# _BNApplyDebugInfo
_BNApplyDebugInfo = core.BNApplyDebugInfo
_BNApplyDebugInfo.restype = None
_BNApplyDebugInfo.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDebugInfo),
]
# noinspection PyPep8Naming
def BNApplyDebugInfo(
view: ctypes.POINTER(BNBinaryView),
newDebugInfo: ctypes.POINTER(BNDebugInfo)
) -> None:
return _BNApplyDebugInfo(view, newDebugInfo)
# -------------------------------------------------------
# _BNApplyImportedTypes
_BNApplyImportedTypes = core.BNApplyImportedTypes
_BNApplyImportedTypes.restype = None
_BNApplyImportedTypes.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNSymbol),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNApplyImportedTypes(
func: ctypes.POINTER(BNFunction),
sym: ctypes.POINTER(BNSymbol),
type: ctypes.POINTER(BNType)
) -> None:
return _BNApplyImportedTypes(func, sym, type)
# -------------------------------------------------------
# _BNApplySnapshotData
_BNApplySnapshotData = core.BNApplySnapshotData
_BNApplySnapshotData.restype = None
_BNApplySnapshotData.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNKeyValueStore),
ctypes.POINTER(BNKeyValueStore),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_bool,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNApplySnapshotData(
file: ctypes.POINTER(BNFileMetadata),
view: ctypes.POINTER(BNBinaryView),
data: ctypes.POINTER(BNKeyValueStore),
cache: ctypes.POINTER(BNKeyValueStore),
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
openForConfiguration: bool,
restoreRawView: bool
) -> None:
return _BNApplySnapshotData(file, view, data, cache, ctxt, progress, openForConfiguration, restoreRawView)
# -------------------------------------------------------
# _BNArchitectureAlwaysBranch
_BNArchitectureAlwaysBranch = core.BNArchitectureAlwaysBranch
_BNArchitectureAlwaysBranch.restype = ctypes.c_bool
_BNArchitectureAlwaysBranch.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNArchitectureAlwaysBranch(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: int
) -> bool:
return _BNArchitectureAlwaysBranch(arch, data, addr, len)
# -------------------------------------------------------
# _BNArchitectureConvertToNop
_BNArchitectureConvertToNop = core.BNArchitectureConvertToNop
_BNArchitectureConvertToNop.restype = ctypes.c_bool
_BNArchitectureConvertToNop.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNArchitectureConvertToNop(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: int
) -> bool:
return _BNArchitectureConvertToNop(arch, data, addr, len)
# -------------------------------------------------------
# _BNArchitectureGetRelocationHandler
_BNArchitectureGetRelocationHandler = core.BNArchitectureGetRelocationHandler
_BNArchitectureGetRelocationHandler.restype = ctypes.POINTER(BNRelocationHandler)
_BNArchitectureGetRelocationHandler.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNArchitectureGetRelocationHandler(
arch: ctypes.POINTER(BNArchitecture),
viewName: Optional[str]
) -> Optional[ctypes.POINTER(BNRelocationHandler)]:
result = _BNArchitectureGetRelocationHandler(arch, cstr(viewName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNArchitectureInvertBranch
_BNArchitectureInvertBranch = core.BNArchitectureInvertBranch
_BNArchitectureInvertBranch.restype = ctypes.c_bool
_BNArchitectureInvertBranch.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNArchitectureInvertBranch(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: int
) -> bool:
return _BNArchitectureInvertBranch(arch, data, addr, len)
# -------------------------------------------------------
# _BNArchitectureRegisterRelocationHandler
_BNArchitectureRegisterRelocationHandler = core.BNArchitectureRegisterRelocationHandler
_BNArchitectureRegisterRelocationHandler.restype = None
_BNArchitectureRegisterRelocationHandler.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
ctypes.POINTER(BNRelocationHandler),
]
# noinspection PyPep8Naming
def BNArchitectureRegisterRelocationHandler(
arch: ctypes.POINTER(BNArchitecture),
viewName: Optional[str],
handler: ctypes.POINTER(BNRelocationHandler)
) -> None:
return _BNArchitectureRegisterRelocationHandler(arch, cstr(viewName), handler)
# -------------------------------------------------------
# _BNArchitectureSkipAndReturnValue
_BNArchitectureSkipAndReturnValue = core.BNArchitectureSkipAndReturnValue
_BNArchitectureSkipAndReturnValue.restype = ctypes.c_bool
_BNArchitectureSkipAndReturnValue.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNArchitectureSkipAndReturnValue(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: int,
value: int
) -> bool:
return _BNArchitectureSkipAndReturnValue(arch, data, addr, len, value)
# -------------------------------------------------------
# _BNAreArgumentRegistersSharedIndex
_BNAreArgumentRegistersSharedIndex = core.BNAreArgumentRegistersSharedIndex
_BNAreArgumentRegistersSharedIndex.restype = ctypes.c_bool
_BNAreArgumentRegistersSharedIndex.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNAreArgumentRegistersSharedIndex(
cc: ctypes.POINTER(BNCallingConvention)
) -> bool:
return _BNAreArgumentRegistersSharedIndex(cc)
# -------------------------------------------------------
# _BNAreArgumentRegistersUsedForVarArgs
_BNAreArgumentRegistersUsedForVarArgs = core.BNAreArgumentRegistersUsedForVarArgs
_BNAreArgumentRegistersUsedForVarArgs.restype = ctypes.c_bool
_BNAreArgumentRegistersUsedForVarArgs.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNAreArgumentRegistersUsedForVarArgs(
cc: ctypes.POINTER(BNCallingConvention)
) -> bool:
return _BNAreArgumentRegistersUsedForVarArgs(cc)
# -------------------------------------------------------
# _BNAreAutoUpdatesEnabled
_BNAreAutoUpdatesEnabled = core.BNAreAutoUpdatesEnabled
_BNAreAutoUpdatesEnabled.restype = ctypes.c_bool
_BNAreAutoUpdatesEnabled.argtypes = [
]
# noinspection PyPep8Naming
def BNAreAutoUpdatesEnabled(
) -> bool:
return _BNAreAutoUpdatesEnabled()
# -------------------------------------------------------
# _BNAreUpdatesAvailable
_BNAreUpdatesAvailable = core.BNAreUpdatesAvailable
_BNAreUpdatesAvailable.restype = ctypes.c_bool
_BNAreUpdatesAvailable.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNAreUpdatesAvailable(
channel: Optional[str],
expireTime: ctypes.POINTER(ctypes.c_ulonglong),
serverTime: ctypes.POINTER(ctypes.c_ulonglong),
errors: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNAreUpdatesAvailable(cstr(channel), expireTime, serverTime, errors)
# -------------------------------------------------------
# _BNAssemble
_BNAssemble = core.BNAssemble
_BNAssemble.restype = ctypes.c_bool
_BNAssemble.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNAssemble(
arch: ctypes.POINTER(BNArchitecture),
code: Optional[str],
addr: int,
result: ctypes.POINTER(BNDataBuffer),
errors: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNAssemble(arch, cstr(code), addr, result, errors)
# -------------------------------------------------------
# _BNAssignDataBuffer
_BNAssignDataBuffer = core.BNAssignDataBuffer
_BNAssignDataBuffer.restype = None
_BNAssignDataBuffer.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNAssignDataBuffer(
dest: ctypes.POINTER(BNDataBuffer),
src: ctypes.POINTER(BNDataBuffer)
) -> None:
return _BNAssignDataBuffer(dest, src)
# -------------------------------------------------------
# _BNAuthenticateEnterpriseServerWithCredentials
_BNAuthenticateEnterpriseServerWithCredentials = core.BNAuthenticateEnterpriseServerWithCredentials
_BNAuthenticateEnterpriseServerWithCredentials.restype = ctypes.c_bool
_BNAuthenticateEnterpriseServerWithCredentials.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNAuthenticateEnterpriseServerWithCredentials(
username: Optional[str],
password: Optional[str],
remember: bool
) -> bool:
return _BNAuthenticateEnterpriseServerWithCredentials(cstr(username), cstr(password), remember)
# -------------------------------------------------------
# _BNAuthenticateEnterpriseServerWithMethod
_BNAuthenticateEnterpriseServerWithMethod = core.BNAuthenticateEnterpriseServerWithMethod
_BNAuthenticateEnterpriseServerWithMethod.restype = ctypes.c_bool
_BNAuthenticateEnterpriseServerWithMethod.argtypes = [
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNAuthenticateEnterpriseServerWithMethod(
method: Optional[str],
remember: bool
) -> bool:
return _BNAuthenticateEnterpriseServerWithMethod(cstr(method), remember)
# -------------------------------------------------------
# _BNBasicBlockCanExit
_BNBasicBlockCanExit = core.BNBasicBlockCanExit
_BNBasicBlockCanExit.restype = ctypes.c_bool
_BNBasicBlockCanExit.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNBasicBlockCanExit(
block: ctypes.POINTER(BNBasicBlock)
) -> bool:
return _BNBasicBlockCanExit(block)
# -------------------------------------------------------
# _BNBasicBlockHasInvalidInstructions
_BNBasicBlockHasInvalidInstructions = core.BNBasicBlockHasInvalidInstructions
_BNBasicBlockHasInvalidInstructions.restype = ctypes.c_bool
_BNBasicBlockHasInvalidInstructions.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNBasicBlockHasInvalidInstructions(
block: ctypes.POINTER(BNBasicBlock)
) -> bool:
return _BNBasicBlockHasInvalidInstructions(block)
# -------------------------------------------------------
# _BNBasicBlockHasUndeterminedOutgoingEdges
_BNBasicBlockHasUndeterminedOutgoingEdges = core.BNBasicBlockHasUndeterminedOutgoingEdges
_BNBasicBlockHasUndeterminedOutgoingEdges.restype = ctypes.c_bool
_BNBasicBlockHasUndeterminedOutgoingEdges.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNBasicBlockHasUndeterminedOutgoingEdges(
block: ctypes.POINTER(BNBasicBlock)
) -> bool:
return _BNBasicBlockHasUndeterminedOutgoingEdges(block)
# -------------------------------------------------------
# _BNBasicBlockSetCanExit
_BNBasicBlockSetCanExit = core.BNBasicBlockSetCanExit
_BNBasicBlockSetCanExit.restype = None
_BNBasicBlockSetCanExit.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNBasicBlockSetCanExit(
block: ctypes.POINTER(BNBasicBlock),
value: bool
) -> None:
return _BNBasicBlockSetCanExit(block, value)
# -------------------------------------------------------
# _BNBeginBackgroundTask
_BNBeginBackgroundTask = core.BNBeginBackgroundTask
_BNBeginBackgroundTask.restype = ctypes.POINTER(BNBackgroundTask)
_BNBeginBackgroundTask.argtypes = [
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNBeginBackgroundTask(
initialText: Optional[str],
canCancel: bool
) -> Optional[ctypes.POINTER(BNBackgroundTask)]:
result = _BNBeginBackgroundTask(cstr(initialText), canCancel)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBeginBulkModifySymbols
_BNBeginBulkModifySymbols = core.BNBeginBulkModifySymbols
_BNBeginBulkModifySymbols.restype = None
_BNBeginBulkModifySymbols.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNBeginBulkModifySymbols(
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNBeginBulkModifySymbols(view)
# -------------------------------------------------------
# _BNBeginKeyValueStoreNamespace
_BNBeginKeyValueStoreNamespace = core.BNBeginKeyValueStoreNamespace
_BNBeginKeyValueStoreNamespace.restype = None
_BNBeginKeyValueStoreNamespace.argtypes = [
ctypes.POINTER(BNKeyValueStore),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBeginKeyValueStoreNamespace(
store: ctypes.POINTER(BNKeyValueStore),
name: Optional[str]
) -> None:
return _BNBeginKeyValueStoreNamespace(store, cstr(name))
# -------------------------------------------------------
# _BNBeginUndoActions
_BNBeginUndoActions = core.BNBeginUndoActions
_BNBeginUndoActions.restype = ctypes.POINTER(ctypes.c_byte)
_BNBeginUndoActions.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNBeginUndoActions(
file: ctypes.POINTER(BNFileMetadata),
anonymousAllowed: bool
) -> Optional[Optional[str]]:
result = _BNBeginUndoActions(file, anonymousAllowed)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNBinaryViewAddExternalLibrary
_BNBinaryViewAddExternalLibrary = core.BNBinaryViewAddExternalLibrary
_BNBinaryViewAddExternalLibrary.restype = ctypes.POINTER(BNExternalLibrary)
_BNBinaryViewAddExternalLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNProjectFile),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNBinaryViewAddExternalLibrary(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str],
backingFile: ctypes.POINTER(BNProjectFile),
isAuto: bool
) -> Optional[ctypes.POINTER(BNExternalLibrary)]:
result = _BNBinaryViewAddExternalLibrary(view, cstr(name), backingFile, isAuto)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewAddExternalLocation
_BNBinaryViewAddExternalLocation = core.BNBinaryViewAddExternalLocation
_BNBinaryViewAddExternalLocation.restype = ctypes.POINTER(BNExternalLocation)
_BNBinaryViewAddExternalLocation.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNSymbol),
ctypes.POINTER(BNExternalLibrary),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNBinaryViewAddExternalLocation(
view: ctypes.POINTER(BNBinaryView),
sourceSymbol: ctypes.POINTER(BNSymbol),
library: ctypes.POINTER(BNExternalLibrary),
targetSymbol: Optional[str],
targetAddress: ctypes.POINTER(ctypes.c_ulonglong),
isAuto: bool
) -> Optional[ctypes.POINTER(BNExternalLocation)]:
result = _BNBinaryViewAddExternalLocation(view, sourceSymbol, library, cstr(targetSymbol), targetAddress, isAuto)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewAttachTypeArchive
_BNBinaryViewAttachTypeArchive = core.BNBinaryViewAttachTypeArchive
_BNBinaryViewAttachTypeArchive.restype = ctypes.POINTER(BNTypeArchive)
_BNBinaryViewAttachTypeArchive.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewAttachTypeArchive(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str],
path: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeArchive)]:
result = _BNBinaryViewAttachTypeArchive(view, cstr(id), cstr(path))
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewDetachTypeArchive
_BNBinaryViewDetachTypeArchive = core.BNBinaryViewDetachTypeArchive
_BNBinaryViewDetachTypeArchive.restype = ctypes.c_bool
_BNBinaryViewDetachTypeArchive.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewDetachTypeArchive(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str]
) -> bool:
return _BNBinaryViewDetachTypeArchive(view, cstr(id))
# -------------------------------------------------------
# _BNBinaryViewDisassociateTypeArchiveType
_BNBinaryViewDisassociateTypeArchiveType = core.BNBinaryViewDisassociateTypeArchiveType
_BNBinaryViewDisassociateTypeArchiveType.restype = ctypes.c_bool
_BNBinaryViewDisassociateTypeArchiveType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewDisassociateTypeArchiveType(
view: ctypes.POINTER(BNBinaryView),
typeId: Optional[str]
) -> bool:
return _BNBinaryViewDisassociateTypeArchiveType(view, cstr(typeId))
# -------------------------------------------------------
# _BNBinaryViewExportObjectToTypeLibrary
_BNBinaryViewExportObjectToTypeLibrary = core.BNBinaryViewExportObjectToTypeLibrary
_BNBinaryViewExportObjectToTypeLibrary.restype = None
_BNBinaryViewExportObjectToTypeLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNBinaryViewExportObjectToTypeLibrary(
view: ctypes.POINTER(BNBinaryView),
lib: ctypes.POINTER(BNTypeLibrary),
name: ctypes.POINTER(BNQualifiedName),
type: ctypes.POINTER(BNType)
) -> None:
return _BNBinaryViewExportObjectToTypeLibrary(view, lib, name, type)
# -------------------------------------------------------
# _BNBinaryViewExportTypeToTypeLibrary
_BNBinaryViewExportTypeToTypeLibrary = core.BNBinaryViewExportTypeToTypeLibrary
_BNBinaryViewExportTypeToTypeLibrary.restype = None
_BNBinaryViewExportTypeToTypeLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNBinaryViewExportTypeToTypeLibrary(
view: ctypes.POINTER(BNBinaryView),
lib: ctypes.POINTER(BNTypeLibrary),
name: ctypes.POINTER(BNQualifiedName),
type: ctypes.POINTER(BNType)
) -> None:
return _BNBinaryViewExportTypeToTypeLibrary(view, lib, name, type)
# -------------------------------------------------------
# _BNBinaryViewGetAssociatedTypeArchiveTypeSource
_BNBinaryViewGetAssociatedTypeArchiveTypeSource = core.BNBinaryViewGetAssociatedTypeArchiveTypeSource
_BNBinaryViewGetAssociatedTypeArchiveTypeSource.restype = ctypes.c_bool
_BNBinaryViewGetAssociatedTypeArchiveTypeSource.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNBinaryViewGetAssociatedTypeArchiveTypeSource(
view: ctypes.POINTER(BNBinaryView),
archiveId: Optional[str],
archiveTypeId: Optional[str],
typeId: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNBinaryViewGetAssociatedTypeArchiveTypeSource(view, cstr(archiveId), cstr(archiveTypeId), typeId)
# -------------------------------------------------------
# _BNBinaryViewGetAssociatedTypeArchiveTypeTarget
_BNBinaryViewGetAssociatedTypeArchiveTypeTarget = core.BNBinaryViewGetAssociatedTypeArchiveTypeTarget
_BNBinaryViewGetAssociatedTypeArchiveTypeTarget.restype = ctypes.c_bool
_BNBinaryViewGetAssociatedTypeArchiveTypeTarget.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNBinaryViewGetAssociatedTypeArchiveTypeTarget(
view: ctypes.POINTER(BNBinaryView),
typeId: Optional[str],
archiveId: ctypes.POINTER(ctypes.c_char_p),
archiveTypeId: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNBinaryViewGetAssociatedTypeArchiveTypeTarget(view, cstr(typeId), archiveId, archiveTypeId)
# -------------------------------------------------------
# _BNBinaryViewGetAssociatedTypeArchiveTypes
_BNBinaryViewGetAssociatedTypeArchiveTypes = core.BNBinaryViewGetAssociatedTypeArchiveTypes
_BNBinaryViewGetAssociatedTypeArchiveTypes.restype = ctypes.c_ulonglong
_BNBinaryViewGetAssociatedTypeArchiveTypes.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
]
# noinspection PyPep8Naming
def BNBinaryViewGetAssociatedTypeArchiveTypes(
view: ctypes.POINTER(BNBinaryView),
typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
archiveIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
archiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
) -> int:
return _BNBinaryViewGetAssociatedTypeArchiveTypes(view, typeIds, archiveIds, archiveTypeIds)
# -------------------------------------------------------
# _BNBinaryViewGetAssociatedTypesFromArchive
_BNBinaryViewGetAssociatedTypesFromArchive = core.BNBinaryViewGetAssociatedTypesFromArchive
_BNBinaryViewGetAssociatedTypesFromArchive.restype = ctypes.c_ulonglong
_BNBinaryViewGetAssociatedTypesFromArchive.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
]
# noinspection PyPep8Naming
def BNBinaryViewGetAssociatedTypesFromArchive(
view: ctypes.POINTER(BNBinaryView),
archiveId: Optional[str],
typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
archiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
) -> int:
return _BNBinaryViewGetAssociatedTypesFromArchive(view, cstr(archiveId), typeIds, archiveTypeIds)
# -------------------------------------------------------
# _BNBinaryViewGetAutoMetadata
_BNBinaryViewGetAutoMetadata = core.BNBinaryViewGetAutoMetadata
_BNBinaryViewGetAutoMetadata.restype = ctypes.POINTER(BNMetadata)
_BNBinaryViewGetAutoMetadata.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNBinaryViewGetAutoMetadata(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNBinaryViewGetAutoMetadata(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewGetExternalLibraries
_BNBinaryViewGetExternalLibraries = core.BNBinaryViewGetExternalLibraries
_BNBinaryViewGetExternalLibraries.restype = ctypes.POINTER(ctypes.POINTER(BNExternalLibrary))
_BNBinaryViewGetExternalLibraries.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNBinaryViewGetExternalLibraries(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNExternalLibrary))]:
result = _BNBinaryViewGetExternalLibraries(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewGetExternalLibrary
_BNBinaryViewGetExternalLibrary = core.BNBinaryViewGetExternalLibrary
_BNBinaryViewGetExternalLibrary.restype = ctypes.POINTER(BNExternalLibrary)
_BNBinaryViewGetExternalLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewGetExternalLibrary(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNExternalLibrary)]:
result = _BNBinaryViewGetExternalLibrary(view, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewGetExternalLocation
_BNBinaryViewGetExternalLocation = core.BNBinaryViewGetExternalLocation
_BNBinaryViewGetExternalLocation.restype = ctypes.POINTER(BNExternalLocation)
_BNBinaryViewGetExternalLocation.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNBinaryViewGetExternalLocation(
view: ctypes.POINTER(BNBinaryView),
sourceSymbol: ctypes.POINTER(BNSymbol)
) -> Optional[ctypes.POINTER(BNExternalLocation)]:
result = _BNBinaryViewGetExternalLocation(view, sourceSymbol)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewGetExternalLocations
_BNBinaryViewGetExternalLocations = core.BNBinaryViewGetExternalLocations
_BNBinaryViewGetExternalLocations.restype = ctypes.POINTER(ctypes.POINTER(BNExternalLocation))
_BNBinaryViewGetExternalLocations.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNBinaryViewGetExternalLocations(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNExternalLocation))]:
result = _BNBinaryViewGetExternalLocations(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewGetLoadSettings
_BNBinaryViewGetLoadSettings = core.BNBinaryViewGetLoadSettings
_BNBinaryViewGetLoadSettings.restype = ctypes.POINTER(BNSettings)
_BNBinaryViewGetLoadSettings.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewGetLoadSettings(
view: ctypes.POINTER(BNBinaryView),
typeName: Optional[str]
) -> Optional[ctypes.POINTER(BNSettings)]:
result = _BNBinaryViewGetLoadSettings(view, cstr(typeName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewGetLoadSettingsTypeNames
_BNBinaryViewGetLoadSettingsTypeNames = core.BNBinaryViewGetLoadSettingsTypeNames
_BNBinaryViewGetLoadSettingsTypeNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNBinaryViewGetLoadSettingsTypeNames.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNBinaryViewGetLoadSettingsTypeNames(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNBinaryViewGetLoadSettingsTypeNames(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewGetMetadata
_BNBinaryViewGetMetadata = core.BNBinaryViewGetMetadata
_BNBinaryViewGetMetadata.restype = ctypes.POINTER(BNMetadata)
_BNBinaryViewGetMetadata.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNBinaryViewGetMetadata(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNBinaryViewGetMetadata(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewGetTypeArchive
_BNBinaryViewGetTypeArchive = core.BNBinaryViewGetTypeArchive
_BNBinaryViewGetTypeArchive.restype = ctypes.POINTER(BNTypeArchive)
_BNBinaryViewGetTypeArchive.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchive(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeArchive)]:
result = _BNBinaryViewGetTypeArchive(view, cstr(id))
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewGetTypeArchivePath
_BNBinaryViewGetTypeArchivePath = core.BNBinaryViewGetTypeArchivePath
_BNBinaryViewGetTypeArchivePath.restype = ctypes.POINTER(ctypes.c_byte)
_BNBinaryViewGetTypeArchivePath.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchivePath(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str]
) -> Optional[Optional[str]]:
result = _BNBinaryViewGetTypeArchivePath(view, cstr(id))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNBinaryViewGetTypeArchiveSyncStatus
_BNBinaryViewGetTypeArchiveSyncStatus = core.BNBinaryViewGetTypeArchiveSyncStatus
_BNBinaryViewGetTypeArchiveSyncStatus.restype = SyncStatusEnum
_BNBinaryViewGetTypeArchiveSyncStatus.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchiveSyncStatus(
view: ctypes.POINTER(BNBinaryView),
typeId: Optional[str]
) -> SyncStatus:
return _BNBinaryViewGetTypeArchiveSyncStatus(view, cstr(typeId))
# -------------------------------------------------------
# _BNBinaryViewGetTypeArchiveTypeNameList
_BNBinaryViewGetTypeArchiveTypeNameList = core.BNBinaryViewGetTypeArchiveTypeNameList
_BNBinaryViewGetTypeArchiveTypeNameList.restype = ctypes.c_ulonglong
_BNBinaryViewGetTypeArchiveTypeNameList.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
]
# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchiveTypeNameList(
view: ctypes.POINTER(BNBinaryView),
names: ctypes.POINTER(ctypes.POINTER(BNQualifiedName))
) -> int:
return _BNBinaryViewGetTypeArchiveTypeNameList(view, names)
# -------------------------------------------------------
# _BNBinaryViewGetTypeArchiveTypeNames
_BNBinaryViewGetTypeArchiveTypeNames = core.BNBinaryViewGetTypeArchiveTypeNames
_BNBinaryViewGetTypeArchiveTypeNames.restype = ctypes.c_ulonglong
_BNBinaryViewGetTypeArchiveTypeNames.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
]
# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchiveTypeNames(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName),
archiveIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
archiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
) -> int:
return _BNBinaryViewGetTypeArchiveTypeNames(view, name, archiveIds, archiveTypeIds)
# -------------------------------------------------------
# _BNBinaryViewGetTypeArchives
_BNBinaryViewGetTypeArchives = core.BNBinaryViewGetTypeArchives
_BNBinaryViewGetTypeArchives.restype = ctypes.c_ulonglong
_BNBinaryViewGetTypeArchives.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
]
# noinspection PyPep8Naming
def BNBinaryViewGetTypeArchives(
view: ctypes.POINTER(BNBinaryView),
ids: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
paths: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
) -> int:
return _BNBinaryViewGetTypeArchives(view, ids, paths)
# -------------------------------------------------------
# _BNBinaryViewGetTypeNameByGuid
_BNBinaryViewGetTypeNameByGuid = core.BNBinaryViewGetTypeNameByGuid
_BNBinaryViewGetTypeNameByGuid.restype = BNQualifiedName
_BNBinaryViewGetTypeNameByGuid.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewGetTypeNameByGuid(
view: ctypes.POINTER(BNBinaryView),
guid: Optional[str]
) -> BNQualifiedName:
return _BNBinaryViewGetTypeNameByGuid(view, cstr(guid))
# -------------------------------------------------------
# _BNBinaryViewImportTypeLibraryObject
_BNBinaryViewImportTypeLibraryObject = core.BNBinaryViewImportTypeLibraryObject
_BNBinaryViewImportTypeLibraryObject.restype = ctypes.POINTER(BNType)
_BNBinaryViewImportTypeLibraryObject.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNBinaryViewImportTypeLibraryObject(
view: ctypes.POINTER(BNBinaryView),
lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNBinaryViewImportTypeLibraryObject(view, lib, name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewImportTypeLibraryType
_BNBinaryViewImportTypeLibraryType = core.BNBinaryViewImportTypeLibraryType
_BNBinaryViewImportTypeLibraryType.restype = ctypes.POINTER(BNType)
_BNBinaryViewImportTypeLibraryType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNBinaryViewImportTypeLibraryType(
view: ctypes.POINTER(BNBinaryView),
lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNBinaryViewImportTypeLibraryType(view, lib, name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewImportTypeLibraryTypeByGuid
_BNBinaryViewImportTypeLibraryTypeByGuid = core.BNBinaryViewImportTypeLibraryTypeByGuid
_BNBinaryViewImportTypeLibraryTypeByGuid.restype = ctypes.POINTER(BNType)
_BNBinaryViewImportTypeLibraryTypeByGuid.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewImportTypeLibraryTypeByGuid(
view: ctypes.POINTER(BNBinaryView),
guid: Optional[str]
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNBinaryViewImportTypeLibraryTypeByGuid(view, cstr(guid))
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewLookupImportedObjectLibrary
_BNBinaryViewLookupImportedObjectLibrary = core.BNBinaryViewLookupImportedObjectLibrary
_BNBinaryViewLookupImportedObjectLibrary.restype = ctypes.c_bool
_BNBinaryViewLookupImportedObjectLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNPlatform),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNBinaryViewLookupImportedObjectLibrary(
view: ctypes.POINTER(BNBinaryView),
tgtPlatform: ctypes.POINTER(BNPlatform),
tgtAddr: int,
lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
name: ctypes.POINTER(BNQualifiedName)
) -> bool:
return _BNBinaryViewLookupImportedObjectLibrary(view, tgtPlatform, tgtAddr, lib, name)
# -------------------------------------------------------
# _BNBinaryViewLookupImportedTypeLibrary
_BNBinaryViewLookupImportedTypeLibrary = core.BNBinaryViewLookupImportedTypeLibrary
_BNBinaryViewLookupImportedTypeLibrary.restype = ctypes.c_bool
_BNBinaryViewLookupImportedTypeLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNBinaryViewLookupImportedTypeLibrary(
view: ctypes.POINTER(BNBinaryView),
typeName: ctypes.POINTER(BNQualifiedName),
lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
resultName: ctypes.POINTER(BNQualifiedName)
) -> bool:
return _BNBinaryViewLookupImportedTypeLibrary(view, typeName, lib, resultName)
# -------------------------------------------------------
# _BNBinaryViewPullTypeArchiveTypes
_BNBinaryViewPullTypeArchiveTypes = core.BNBinaryViewPullTypeArchiveTypes
_BNBinaryViewPullTypeArchiveTypes.restype = ctypes.c_bool
_BNBinaryViewPullTypeArchiveTypes.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNBinaryViewPullTypeArchiveTypes(
view: ctypes.POINTER(BNBinaryView),
archiveId: Optional[str],
archiveTypeIds: ctypes.POINTER(ctypes.c_char_p),
archiveTypeIdCount: int,
updatedArchiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
updatedAnalysisTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
updatedTypeCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNBinaryViewPullTypeArchiveTypes(view, cstr(archiveId), archiveTypeIds, archiveTypeIdCount, updatedArchiveTypeIds, updatedAnalysisTypeIds, updatedTypeCount)
# -------------------------------------------------------
# _BNBinaryViewPushTypeArchiveTypes
_BNBinaryViewPushTypeArchiveTypes = core.BNBinaryViewPushTypeArchiveTypes
_BNBinaryViewPushTypeArchiveTypes.restype = ctypes.c_bool
_BNBinaryViewPushTypeArchiveTypes.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNBinaryViewPushTypeArchiveTypes(
view: ctypes.POINTER(BNBinaryView),
archiveId: Optional[str],
typeIds: ctypes.POINTER(ctypes.c_char_p),
typeIdCount: int,
updatedAnalysisTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
updatedArchiveTypeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
updatedTypeCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNBinaryViewPushTypeArchiveTypes(view, cstr(archiveId), typeIds, typeIdCount, updatedAnalysisTypeIds, updatedArchiveTypeIds, updatedTypeCount)
# -------------------------------------------------------
# _BNBinaryViewQueryMetadata
_BNBinaryViewQueryMetadata = core.BNBinaryViewQueryMetadata
_BNBinaryViewQueryMetadata.restype = ctypes.POINTER(BNMetadata)
_BNBinaryViewQueryMetadata.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewQueryMetadata(
view: ctypes.POINTER(BNBinaryView),
key: Optional[str]
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNBinaryViewQueryMetadata(view, cstr(key))
if not result:
return None
return result
# -------------------------------------------------------
# _BNBinaryViewRecordImportedObjectLibrary
_BNBinaryViewRecordImportedObjectLibrary = core.BNBinaryViewRecordImportedObjectLibrary
_BNBinaryViewRecordImportedObjectLibrary.restype = None
_BNBinaryViewRecordImportedObjectLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNPlatform),
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNBinaryViewRecordImportedObjectLibrary(
view: ctypes.POINTER(BNBinaryView),
tgtPlatform: ctypes.POINTER(BNPlatform),
tgtAddr: int,
lib: ctypes.POINTER(BNTypeLibrary),
name: ctypes.POINTER(BNQualifiedName)
) -> None:
return _BNBinaryViewRecordImportedObjectLibrary(view, tgtPlatform, tgtAddr, lib, name)
# -------------------------------------------------------
# _BNBinaryViewRemoveExternalLibrary
_BNBinaryViewRemoveExternalLibrary = core.BNBinaryViewRemoveExternalLibrary
_BNBinaryViewRemoveExternalLibrary.restype = None
_BNBinaryViewRemoveExternalLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewRemoveExternalLibrary(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> None:
return _BNBinaryViewRemoveExternalLibrary(view, cstr(name))
# -------------------------------------------------------
# _BNBinaryViewRemoveExternalLocation
_BNBinaryViewRemoveExternalLocation = core.BNBinaryViewRemoveExternalLocation
_BNBinaryViewRemoveExternalLocation.restype = None
_BNBinaryViewRemoveExternalLocation.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNBinaryViewRemoveExternalLocation(
view: ctypes.POINTER(BNBinaryView),
sourceSymbol: ctypes.POINTER(BNSymbol)
) -> None:
return _BNBinaryViewRemoveExternalLocation(view, sourceSymbol)
# -------------------------------------------------------
# _BNBinaryViewRemoveMetadata
_BNBinaryViewRemoveMetadata = core.BNBinaryViewRemoveMetadata
_BNBinaryViewRemoveMetadata.restype = None
_BNBinaryViewRemoveMetadata.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNBinaryViewRemoveMetadata(
view: ctypes.POINTER(BNBinaryView),
key: Optional[str]
) -> None:
return _BNBinaryViewRemoveMetadata(view, cstr(key))
# -------------------------------------------------------
# _BNBinaryViewSetLoadSettings
_BNBinaryViewSetLoadSettings = core.BNBinaryViewSetLoadSettings
_BNBinaryViewSetLoadSettings.restype = None
_BNBinaryViewSetLoadSettings.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNSettings),
]
# noinspection PyPep8Naming
def BNBinaryViewSetLoadSettings(
view: ctypes.POINTER(BNBinaryView),
typeName: Optional[str],
settings: ctypes.POINTER(BNSettings)
) -> None:
return _BNBinaryViewSetLoadSettings(view, cstr(typeName), settings)
# -------------------------------------------------------
# _BNBinaryViewSetManualDependencies
_BNBinaryViewSetManualDependencies = core.BNBinaryViewSetManualDependencies
_BNBinaryViewSetManualDependencies.restype = None
_BNBinaryViewSetManualDependencies.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNBinaryViewSetManualDependencies(
view: ctypes.POINTER(BNBinaryView),
viewTypeNames: ctypes.POINTER(BNQualifiedName),
libTypeNames: ctypes.POINTER(BNQualifiedName),
libNames: ctypes.POINTER(ctypes.c_char_p),
count: int
) -> None:
return _BNBinaryViewSetManualDependencies(view, viewTypeNames, libTypeNames, libNames, count)
# -------------------------------------------------------
# _BNBinaryViewStoreMetadata
_BNBinaryViewStoreMetadata = core.BNBinaryViewStoreMetadata
_BNBinaryViewStoreMetadata.restype = None
_BNBinaryViewStoreMetadata.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNMetadata),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNBinaryViewStoreMetadata(
view: ctypes.POINTER(BNBinaryView),
key: Optional[str],
value: ctypes.POINTER(BNMetadata),
isAuto: bool
) -> None:
return _BNBinaryViewStoreMetadata(view, cstr(key), value, isAuto)
# -------------------------------------------------------
# _BNCanArchitectureAssemble
_BNCanArchitectureAssemble = core.BNCanArchitectureAssemble
_BNCanArchitectureAssemble.restype = ctypes.c_bool
_BNCanArchitectureAssemble.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNCanArchitectureAssemble(
arch: ctypes.POINTER(BNArchitecture)
) -> bool:
return _BNCanArchitectureAssemble(arch)
# -------------------------------------------------------
# _BNCanAssemble
_BNCanAssemble = core.BNCanAssemble
_BNCanAssemble.restype = ctypes.c_bool
_BNCanAssemble.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNCanAssemble(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture)
) -> bool:
return _BNCanAssemble(view, arch)
# -------------------------------------------------------
# _BNCanCancelBackgroundTask
_BNCanCancelBackgroundTask = core.BNCanCancelBackgroundTask
_BNCanCancelBackgroundTask.restype = ctypes.c_bool
_BNCanCancelBackgroundTask.argtypes = [
ctypes.POINTER(BNBackgroundTask),
]
# noinspection PyPep8Naming
def BNCanCancelBackgroundTask(
task: ctypes.POINTER(BNBackgroundTask)
) -> bool:
return _BNCanCancelBackgroundTask(task)
# -------------------------------------------------------
# _BNCanFunctionReturn
_BNCanFunctionReturn = core.BNCanFunctionReturn
_BNCanFunctionReturn.restype = BNBoolWithConfidence
_BNCanFunctionReturn.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNCanFunctionReturn(
func: ctypes.POINTER(BNFunction)
) -> BNBoolWithConfidence:
return _BNCanFunctionReturn(func)
# -------------------------------------------------------
# _BNCanRedo
_BNCanRedo = core.BNCanRedo
_BNCanRedo.restype = ctypes.c_bool
_BNCanRedo.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNCanRedo(
file: ctypes.POINTER(BNFileMetadata)
) -> bool:
return _BNCanRedo(file)
# -------------------------------------------------------
# _BNCanUndo
_BNCanUndo = core.BNCanUndo
_BNCanUndo.restype = ctypes.c_bool
_BNCanUndo.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNCanUndo(
file: ctypes.POINTER(BNFileMetadata)
) -> bool:
return _BNCanUndo(file)
# -------------------------------------------------------
# _BNCancelAnalysisCompletionEvent
_BNCancelAnalysisCompletionEvent = core.BNCancelAnalysisCompletionEvent
_BNCancelAnalysisCompletionEvent.restype = None
_BNCancelAnalysisCompletionEvent.argtypes = [
ctypes.POINTER(BNAnalysisCompletionEvent),
]
# noinspection PyPep8Naming
def BNCancelAnalysisCompletionEvent(
event: ctypes.POINTER(BNAnalysisCompletionEvent)
) -> None:
return _BNCancelAnalysisCompletionEvent(event)
# -------------------------------------------------------
# _BNCancelBackgroundTask
_BNCancelBackgroundTask = core.BNCancelBackgroundTask
_BNCancelBackgroundTask.restype = None
_BNCancelBackgroundTask.argtypes = [
ctypes.POINTER(BNBackgroundTask),
]
# noinspection PyPep8Naming
def BNCancelBackgroundTask(
task: ctypes.POINTER(BNBackgroundTask)
) -> None:
return _BNCancelBackgroundTask(task)
# -------------------------------------------------------
# _BNCancelEnterpriseServerAuthentication
_BNCancelEnterpriseServerAuthentication = core.BNCancelEnterpriseServerAuthentication
_BNCancelEnterpriseServerAuthentication.restype = None
_BNCancelEnterpriseServerAuthentication.argtypes = [
]
# noinspection PyPep8Naming
def BNCancelEnterpriseServerAuthentication(
) -> None:
return _BNCancelEnterpriseServerAuthentication()
# -------------------------------------------------------
# _BNCancelScriptInput
_BNCancelScriptInput = core.BNCancelScriptInput
_BNCancelScriptInput.restype = None
_BNCancelScriptInput.argtypes = [
ctypes.POINTER(BNScriptingInstance),
]
# noinspection PyPep8Naming
def BNCancelScriptInput(
instance: ctypes.POINTER(BNScriptingInstance)
) -> None:
return _BNCancelScriptInput(instance)
# -------------------------------------------------------
# _BNCheckForStringAnnotationType
_BNCheckForStringAnnotationType = core.BNCheckForStringAnnotationType
_BNCheckForStringAnnotationType.restype = ctypes.c_bool
_BNCheckForStringAnnotationType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(StringTypeEnum),
ctypes.c_bool,
ctypes.c_bool,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCheckForStringAnnotationType(
view: ctypes.POINTER(BNBinaryView),
addr: int,
value: ctypes.POINTER(ctypes.c_char_p),
strType: ctypes.POINTER(StringTypeEnum),
allowShortStrings: bool,
allowLargeStrings: bool,
childWidth: int
) -> bool:
return _BNCheckForStringAnnotationType(view, addr, value, strType, allowShortStrings, allowLargeStrings, childWidth)
# -------------------------------------------------------
# _BNClearDataBuffer
_BNClearDataBuffer = core.BNClearDataBuffer
_BNClearDataBuffer.restype = None
_BNClearDataBuffer.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNClearDataBuffer(
buf: ctypes.POINTER(BNDataBuffer)
) -> None:
return _BNClearDataBuffer(buf)
# -------------------------------------------------------
# _BNClearTypeLibraryPlatforms
_BNClearTypeLibraryPlatforms = core.BNClearTypeLibraryPlatforms
_BNClearTypeLibraryPlatforms.restype = None
_BNClearTypeLibraryPlatforms.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNClearTypeLibraryPlatforms(
lib: ctypes.POINTER(BNTypeLibrary)
) -> None:
return _BNClearTypeLibraryPlatforms(lib)
# -------------------------------------------------------
# _BNClearUndoEntries
_BNClearUndoEntries = core.BNClearUndoEntries
_BNClearUndoEntries.restype = None
_BNClearUndoEntries.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNClearUndoEntries(
file: ctypes.POINTER(BNFileMetadata)
) -> None:
return _BNClearUndoEntries(file)
# -------------------------------------------------------
# _BNClearUserVariableValue
_BNClearUserVariableValue = core.BNClearUserVariableValue
_BNClearUserVariableValue.restype = None
_BNClearUserVariableValue.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(BNArchitectureAndAddress),
]
# noinspection PyPep8Naming
def BNClearUserVariableValue(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable),
defSite: ctypes.POINTER(BNArchitectureAndAddress)
) -> None:
return _BNClearUserVariableValue(func, var, defSite)
# -------------------------------------------------------
# _BNCloseFile
_BNCloseFile = core.BNCloseFile
_BNCloseFile.restype = None
_BNCloseFile.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNCloseFile(
file: ctypes.POINTER(BNFileMetadata)
) -> None:
return _BNCloseFile(file)
# -------------------------------------------------------
# _BNCloseLogs
_BNCloseLogs = core.BNCloseLogs
_BNCloseLogs.restype = None
_BNCloseLogs.argtypes = [
]
# noinspection PyPep8Naming
def BNCloseLogs(
) -> None:
return _BNCloseLogs()
# -------------------------------------------------------
# _BNCloseTypeArchive
_BNCloseTypeArchive = core.BNCloseTypeArchive
_BNCloseTypeArchive.restype = None
_BNCloseTypeArchive.argtypes = [
ctypes.POINTER(BNTypeArchive),
]
# noinspection PyPep8Naming
def BNCloseTypeArchive(
archive: ctypes.POINTER(BNTypeArchive)
) -> None:
return _BNCloseTypeArchive(archive)
# -------------------------------------------------------
# _BNCommitUndoActions
_BNCommitUndoActions = core.BNCommitUndoActions
_BNCommitUndoActions.restype = None
_BNCommitUndoActions.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCommitUndoActions(
file: ctypes.POINTER(BNFileMetadata),
id: Optional[str]
) -> None:
return _BNCommitUndoActions(file, cstr(id))
# -------------------------------------------------------
# _BNCompareLinearViewCursors
_BNCompareLinearViewCursors = core.BNCompareLinearViewCursors
_BNCompareLinearViewCursors.restype = ctypes.c_int
_BNCompareLinearViewCursors.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNCompareLinearViewCursors(
a: ctypes.POINTER(BNLinearViewCursor),
b: ctypes.POINTER(BNLinearViewCursor)
) -> int:
return _BNCompareLinearViewCursors(a, b)
# -------------------------------------------------------
# _BNCompareLinearViewObjectChildren
_BNCompareLinearViewObjectChildren = core.BNCompareLinearViewObjectChildren
_BNCompareLinearViewObjectChildren.restype = ctypes.c_int
_BNCompareLinearViewObjectChildren.argtypes = [
ctypes.POINTER(BNLinearViewObject),
ctypes.POINTER(BNLinearViewObject),
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNCompareLinearViewObjectChildren(
obj: ctypes.POINTER(BNLinearViewObject),
a: ctypes.POINTER(BNLinearViewObject),
b: ctypes.POINTER(BNLinearViewObject)
) -> int:
return _BNCompareLinearViewObjectChildren(obj, a, b)
# -------------------------------------------------------
# _BNComponentAddAllMembersFromComponent
_BNComponentAddAllMembersFromComponent = core.BNComponentAddAllMembersFromComponent
_BNComponentAddAllMembersFromComponent.restype = None
_BNComponentAddAllMembersFromComponent.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentAddAllMembersFromComponent(
component: ctypes.POINTER(BNComponent),
fromComponent: ctypes.POINTER(BNComponent)
) -> None:
return _BNComponentAddAllMembersFromComponent(component, fromComponent)
# -------------------------------------------------------
# _BNComponentAddComponent
_BNComponentAddComponent = core.BNComponentAddComponent
_BNComponentAddComponent.restype = ctypes.c_bool
_BNComponentAddComponent.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentAddComponent(
parent: ctypes.POINTER(BNComponent),
component: ctypes.POINTER(BNComponent)
) -> bool:
return _BNComponentAddComponent(parent, component)
# -------------------------------------------------------
# _BNComponentAddDataVariable
_BNComponentAddDataVariable = core.BNComponentAddDataVariable
_BNComponentAddDataVariable.restype = ctypes.c_bool
_BNComponentAddDataVariable.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNComponentAddDataVariable(
component: ctypes.POINTER(BNComponent),
address: int
) -> bool:
return _BNComponentAddDataVariable(component, address)
# -------------------------------------------------------
# _BNComponentAddFunctionReference
_BNComponentAddFunctionReference = core.BNComponentAddFunctionReference
_BNComponentAddFunctionReference.restype = ctypes.c_bool
_BNComponentAddFunctionReference.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNComponentAddFunctionReference(
component: ctypes.POINTER(BNComponent),
function: ctypes.POINTER(BNFunction)
) -> bool:
return _BNComponentAddFunctionReference(component, function)
# -------------------------------------------------------
# _BNComponentContainsComponent
_BNComponentContainsComponent = core.BNComponentContainsComponent
_BNComponentContainsComponent.restype = ctypes.c_bool
_BNComponentContainsComponent.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentContainsComponent(
parent: ctypes.POINTER(BNComponent),
component: ctypes.POINTER(BNComponent)
) -> bool:
return _BNComponentContainsComponent(parent, component)
# -------------------------------------------------------
# _BNComponentContainsDataVariable
_BNComponentContainsDataVariable = core.BNComponentContainsDataVariable
_BNComponentContainsDataVariable.restype = ctypes.c_bool
_BNComponentContainsDataVariable.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNComponentContainsDataVariable(
component: ctypes.POINTER(BNComponent),
address: int
) -> bool:
return _BNComponentContainsDataVariable(component, address)
# -------------------------------------------------------
# _BNComponentContainsFunction
_BNComponentContainsFunction = core.BNComponentContainsFunction
_BNComponentContainsFunction.restype = ctypes.c_bool
_BNComponentContainsFunction.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNComponentContainsFunction(
component: ctypes.POINTER(BNComponent),
function: ctypes.POINTER(BNFunction)
) -> bool:
return _BNComponentContainsFunction(component, function)
# -------------------------------------------------------
# _BNComponentFreeReferencedTypes
_BNComponentFreeReferencedTypes = core.BNComponentFreeReferencedTypes
_BNComponentFreeReferencedTypes.restype = None
_BNComponentFreeReferencedTypes.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNComponentFreeReferencedTypes(
types: ctypes.POINTER(ctypes.POINTER(BNType)),
count: int
) -> None:
return _BNComponentFreeReferencedTypes(types, count)
# -------------------------------------------------------
# _BNComponentGetContainedComponents
_BNComponentGetContainedComponents = core.BNComponentGetContainedComponents
_BNComponentGetContainedComponents.restype = ctypes.POINTER(ctypes.POINTER(BNComponent))
_BNComponentGetContainedComponents.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNComponentGetContainedComponents(
component: ctypes.POINTER(BNComponent),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNComponent))]:
result = _BNComponentGetContainedComponents(component, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNComponentGetContainedDataVariables
_BNComponentGetContainedDataVariables = core.BNComponentGetContainedDataVariables
_BNComponentGetContainedDataVariables.restype = ctypes.POINTER(BNDataVariable)
_BNComponentGetContainedDataVariables.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNComponentGetContainedDataVariables(
component: ctypes.POINTER(BNComponent),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDataVariable)]:
result = _BNComponentGetContainedDataVariables(component, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNComponentGetContainedFunctions
_BNComponentGetContainedFunctions = core.BNComponentGetContainedFunctions
_BNComponentGetContainedFunctions.restype = ctypes.POINTER(ctypes.POINTER(BNFunction))
_BNComponentGetContainedFunctions.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNComponentGetContainedFunctions(
component: ctypes.POINTER(BNComponent),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFunction))]:
result = _BNComponentGetContainedFunctions(component, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNComponentGetDisplayName
_BNComponentGetDisplayName = core.BNComponentGetDisplayName
_BNComponentGetDisplayName.restype = ctypes.POINTER(ctypes.c_byte)
_BNComponentGetDisplayName.argtypes = [
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentGetDisplayName(
component: ctypes.POINTER(BNComponent)
) -> Optional[Optional[str]]:
result = _BNComponentGetDisplayName(component)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNComponentGetGuid
_BNComponentGetGuid = core.BNComponentGetGuid
_BNComponentGetGuid.restype = ctypes.POINTER(ctypes.c_byte)
_BNComponentGetGuid.argtypes = [
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentGetGuid(
component: ctypes.POINTER(BNComponent)
) -> Optional[Optional[str]]:
result = _BNComponentGetGuid(component)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNComponentGetOriginalName
_BNComponentGetOriginalName = core.BNComponentGetOriginalName
_BNComponentGetOriginalName.restype = ctypes.POINTER(ctypes.c_byte)
_BNComponentGetOriginalName.argtypes = [
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentGetOriginalName(
component: ctypes.POINTER(BNComponent)
) -> Optional[Optional[str]]:
result = _BNComponentGetOriginalName(component)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNComponentGetParent
_BNComponentGetParent = core.BNComponentGetParent
_BNComponentGetParent.restype = ctypes.POINTER(BNComponent)
_BNComponentGetParent.argtypes = [
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentGetParent(
component: ctypes.POINTER(BNComponent)
) -> Optional[ctypes.POINTER(BNComponent)]:
result = _BNComponentGetParent(component)
if not result:
return None
return result
# -------------------------------------------------------
# _BNComponentGetReferencedDataVariables
_BNComponentGetReferencedDataVariables = core.BNComponentGetReferencedDataVariables
_BNComponentGetReferencedDataVariables.restype = ctypes.POINTER(BNDataVariable)
_BNComponentGetReferencedDataVariables.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNComponentGetReferencedDataVariables(
component: ctypes.POINTER(BNComponent),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDataVariable)]:
result = _BNComponentGetReferencedDataVariables(component, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNComponentGetReferencedDataVariablesRecursive
_BNComponentGetReferencedDataVariablesRecursive = core.BNComponentGetReferencedDataVariablesRecursive
_BNComponentGetReferencedDataVariablesRecursive.restype = ctypes.POINTER(BNDataVariable)
_BNComponentGetReferencedDataVariablesRecursive.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNComponentGetReferencedDataVariablesRecursive(
component: ctypes.POINTER(BNComponent),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDataVariable)]:
result = _BNComponentGetReferencedDataVariablesRecursive(component, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNComponentGetReferencedTypes
_BNComponentGetReferencedTypes = core.BNComponentGetReferencedTypes
_BNComponentGetReferencedTypes.restype = ctypes.POINTER(ctypes.POINTER(BNType))
_BNComponentGetReferencedTypes.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNComponentGetReferencedTypes(
component: ctypes.POINTER(BNComponent),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNType))]:
result = _BNComponentGetReferencedTypes(component, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNComponentGetReferencedTypesRecursive
_BNComponentGetReferencedTypesRecursive = core.BNComponentGetReferencedTypesRecursive
_BNComponentGetReferencedTypesRecursive.restype = ctypes.POINTER(ctypes.POINTER(BNType))
_BNComponentGetReferencedTypesRecursive.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNComponentGetReferencedTypesRecursive(
component: ctypes.POINTER(BNComponent),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNType))]:
result = _BNComponentGetReferencedTypesRecursive(component, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNComponentGetView
_BNComponentGetView = core.BNComponentGetView
_BNComponentGetView.restype = ctypes.POINTER(BNBinaryView)
_BNComponentGetView.argtypes = [
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentGetView(
component: ctypes.POINTER(BNComponent)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNComponentGetView(component)
if not result:
return None
return result
# -------------------------------------------------------
# _BNComponentRemoveAllFunctions
_BNComponentRemoveAllFunctions = core.BNComponentRemoveAllFunctions
_BNComponentRemoveAllFunctions.restype = None
_BNComponentRemoveAllFunctions.argtypes = [
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentRemoveAllFunctions(
component: ctypes.POINTER(BNComponent)
) -> None:
return _BNComponentRemoveAllFunctions(component)
# -------------------------------------------------------
# _BNComponentRemoveComponent
_BNComponentRemoveComponent = core.BNComponentRemoveComponent
_BNComponentRemoveComponent.restype = ctypes.c_bool
_BNComponentRemoveComponent.argtypes = [
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentRemoveComponent(
component: ctypes.POINTER(BNComponent)
) -> bool:
return _BNComponentRemoveComponent(component)
# -------------------------------------------------------
# _BNComponentRemoveDataVariable
_BNComponentRemoveDataVariable = core.BNComponentRemoveDataVariable
_BNComponentRemoveDataVariable.restype = ctypes.c_bool
_BNComponentRemoveDataVariable.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNComponentRemoveDataVariable(
component: ctypes.POINTER(BNComponent),
address: int
) -> bool:
return _BNComponentRemoveDataVariable(component, address)
# -------------------------------------------------------
# _BNComponentRemoveFunctionReference
_BNComponentRemoveFunctionReference = core.BNComponentRemoveFunctionReference
_BNComponentRemoveFunctionReference.restype = ctypes.c_bool
_BNComponentRemoveFunctionReference.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNComponentRemoveFunctionReference(
component: ctypes.POINTER(BNComponent),
function: ctypes.POINTER(BNFunction)
) -> bool:
return _BNComponentRemoveFunctionReference(component, function)
# -------------------------------------------------------
# _BNComponentSetName
_BNComponentSetName = core.BNComponentSetName
_BNComponentSetName.restype = None
_BNComponentSetName.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNComponentSetName(
component: ctypes.POINTER(BNComponent),
name: Optional[str]
) -> None:
return _BNComponentSetName(component, cstr(name))
# -------------------------------------------------------
# _BNComponentsEqual
_BNComponentsEqual = core.BNComponentsEqual
_BNComponentsEqual.restype = ctypes.c_bool
_BNComponentsEqual.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentsEqual(
a: ctypes.POINTER(BNComponent),
b: ctypes.POINTER(BNComponent)
) -> bool:
return _BNComponentsEqual(a, b)
# -------------------------------------------------------
# _BNComponentsNotEqual
_BNComponentsNotEqual = core.BNComponentsNotEqual
_BNComponentsNotEqual.restype = ctypes.c_bool
_BNComponentsNotEqual.argtypes = [
ctypes.POINTER(BNComponent),
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNComponentsNotEqual(
a: ctypes.POINTER(BNComponent),
b: ctypes.POINTER(BNComponent)
) -> bool:
return _BNComponentsNotEqual(a, b)
# -------------------------------------------------------
# _BNConnectEnterpriseServer
_BNConnectEnterpriseServer = core.BNConnectEnterpriseServer
_BNConnectEnterpriseServer.restype = ctypes.c_bool
_BNConnectEnterpriseServer.argtypes = [
]
# noinspection PyPep8Naming
def BNConnectEnterpriseServer(
) -> bool:
return _BNConnectEnterpriseServer()
# -------------------------------------------------------
# _BNConnectWebsocketClient
_BNConnectWebsocketClient = core.BNConnectWebsocketClient
_BNConnectWebsocketClient.restype = ctypes.c_bool
_BNConnectWebsocketClient.argtypes = [
ctypes.POINTER(BNWebsocketClient),
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(BNWebsocketClientOutputCallbacks),
]
# noinspection PyPep8Naming
def BNConnectWebsocketClient(
client: ctypes.POINTER(BNWebsocketClient),
url: Optional[str],
headerCount: int,
headerKeys: ctypes.POINTER(ctypes.c_char_p),
headerValues: ctypes.POINTER(ctypes.c_char_p),
callbacks: ctypes.POINTER(BNWebsocketClientOutputCallbacks)
) -> bool:
return _BNConnectWebsocketClient(client, cstr(url), headerCount, headerKeys, headerValues, callbacks)
# -------------------------------------------------------
# _BNConvertToNop
_BNConvertToNop = core.BNConvertToNop
_BNConvertToNop.restype = ctypes.c_bool
_BNConvertToNop.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNConvertToNop(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> bool:
return _BNConvertToNop(view, arch, addr)
# -------------------------------------------------------
# _BNCopyFile
_BNCopyFile = core.BNCopyFile
_BNCopyFile.restype = ctypes.c_bool
_BNCopyFile.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCopyFile(
source: Optional[str],
dest: Optional[str]
) -> bool:
return _BNCopyFile(cstr(source), cstr(dest))
# -------------------------------------------------------
# _BNCoreEnumFromString
_BNCoreEnumFromString = core.BNCoreEnumFromString
_BNCoreEnumFromString.restype = ctypes.c_bool
_BNCoreEnumFromString.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNCoreEnumFromString(
enumName: Optional[str],
value: Optional[str],
result: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNCoreEnumFromString(cstr(enumName), cstr(value), result)
# -------------------------------------------------------
# _BNCoreEnumToString
_BNCoreEnumToString = core.BNCoreEnumToString
_BNCoreEnumToString.restype = ctypes.c_bool
_BNCoreEnumToString.argtypes = [
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNCoreEnumToString(
enumName: Optional[str],
value: int,
result: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNCoreEnumToString(cstr(enumName), value, result)
# -------------------------------------------------------
# _BNCreateActivity
_BNCreateActivity = core.BNCreateActivity
_BNCreateActivity.restype = ctypes.POINTER(BNActivity)
_BNCreateActivity.argtypes = [
ctypes.c_char_p,
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNAnalysisContext)),
]
# noinspection PyPep8Naming
def BNCreateActivity(
configuration: Optional[str],
ctxt: Optional[ctypes.c_void_p],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNAnalysisContext))
) -> Optional[ctypes.POINTER(BNActivity)]:
result = _BNCreateActivity(cstr(configuration), ctxt, action)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateAnalysisContext
_BNCreateAnalysisContext = core.BNCreateAnalysisContext
_BNCreateAnalysisContext.restype = ctypes.POINTER(BNAnalysisContext)
_BNCreateAnalysisContext.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateAnalysisContext(
) -> Optional[ctypes.POINTER(BNAnalysisContext)]:
result = _BNCreateAnalysisContext()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateArrayType
_BNCreateArrayType = core.BNCreateArrayType
_BNCreateArrayType.restype = ctypes.POINTER(BNType)
_BNCreateArrayType.argtypes = [
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateArrayType(
type: ctypes.POINTER(BNTypeWithConfidence),
elem: int
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateArrayType(type, elem)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateArrayTypeBuilder
_BNCreateArrayTypeBuilder = core.BNCreateArrayTypeBuilder
_BNCreateArrayTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateArrayTypeBuilder.argtypes = [
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateArrayTypeBuilder(
type: ctypes.POINTER(BNTypeWithConfidence),
elem: int
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateArrayTypeBuilder(type, elem)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateAutoStackVariable
_BNCreateAutoStackVariable = core.BNCreateAutoStackVariable
_BNCreateAutoStackVariable.restype = None
_BNCreateAutoStackVariable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_longlong,
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateAutoStackVariable(
func: ctypes.POINTER(BNFunction),
offset: int,
type: ctypes.POINTER(BNTypeWithConfidence),
name: Optional[str]
) -> None:
return _BNCreateAutoStackVariable(func, offset, type, cstr(name))
# -------------------------------------------------------
# _BNCreateAutoVariable
_BNCreateAutoVariable = core.BNCreateAutoVariable
_BNCreateAutoVariable.restype = None
_BNCreateAutoVariable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNCreateAutoVariable(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable),
type: ctypes.POINTER(BNTypeWithConfidence),
name: Optional[str],
ignoreDisjointUses: bool
) -> None:
return _BNCreateAutoVariable(func, var, type, cstr(name), ignoreDisjointUses)
# -------------------------------------------------------
# _BNCreateBinaryDataView
_BNCreateBinaryDataView = core.BNCreateBinaryDataView
_BNCreateBinaryDataView.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataView.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNCreateBinaryDataView(
file: ctypes.POINTER(BNFileMetadata)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNCreateBinaryDataView(file)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateBinaryDataViewFromBuffer
_BNCreateBinaryDataViewFromBuffer = core.BNCreateBinaryDataViewFromBuffer
_BNCreateBinaryDataViewFromBuffer.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromBuffer.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromBuffer(
file: ctypes.POINTER(BNFileMetadata),
buf: ctypes.POINTER(BNDataBuffer)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNCreateBinaryDataViewFromBuffer(file, buf)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateBinaryDataViewFromData
_BNCreateBinaryDataViewFromData = core.BNCreateBinaryDataViewFromData
_BNCreateBinaryDataViewFromData.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromData.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_void_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromData(
file: ctypes.POINTER(BNFileMetadata),
data: Optional[ctypes.c_void_p],
len: int
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNCreateBinaryDataViewFromData(file, data, len)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateBinaryDataViewFromFile
_BNCreateBinaryDataViewFromFile = core.BNCreateBinaryDataViewFromFile
_BNCreateBinaryDataViewFromFile.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromFile.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(BNFileAccessor),
]
# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromFile(
file: ctypes.POINTER(BNFileMetadata),
accessor: ctypes.POINTER(BNFileAccessor)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNCreateBinaryDataViewFromFile(file, accessor)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateBinaryDataViewFromFilename
_BNCreateBinaryDataViewFromFilename = core.BNCreateBinaryDataViewFromFilename
_BNCreateBinaryDataViewFromFilename.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryDataViewFromFilename.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateBinaryDataViewFromFilename(
file: ctypes.POINTER(BNFileMetadata),
filename: Optional[str]
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNCreateBinaryDataViewFromFilename(file, cstr(filename))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateBinaryReader
_BNCreateBinaryReader = core.BNCreateBinaryReader
_BNCreateBinaryReader.restype = ctypes.POINTER(BNBinaryReader)
_BNCreateBinaryReader.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNCreateBinaryReader(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNBinaryReader)]:
result = _BNCreateBinaryReader(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateBinaryViewOfType
_BNCreateBinaryViewOfType = core.BNCreateBinaryViewOfType
_BNCreateBinaryViewOfType.restype = ctypes.POINTER(BNBinaryView)
_BNCreateBinaryViewOfType.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNCreateBinaryViewOfType(
type: ctypes.POINTER(BNBinaryViewType),
data: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNCreateBinaryViewOfType(type, data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateBinaryWriter
_BNCreateBinaryWriter = core.BNCreateBinaryWriter
_BNCreateBinaryWriter.restype = ctypes.POINTER(BNBinaryWriter)
_BNCreateBinaryWriter.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNCreateBinaryWriter(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNBinaryWriter)]:
result = _BNCreateBinaryWriter(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateBoolType
_BNCreateBoolType = core.BNCreateBoolType
_BNCreateBoolType.restype = ctypes.POINTER(BNType)
_BNCreateBoolType.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateBoolType(
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateBoolType()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateBoolTypeBuilder
_BNCreateBoolTypeBuilder = core.BNCreateBoolTypeBuilder
_BNCreateBoolTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateBoolTypeBuilder.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateBoolTypeBuilder(
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateBoolTypeBuilder()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateCallingConvention
_BNCreateCallingConvention = core.BNCreateCallingConvention
_BNCreateCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNCreateCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
ctypes.POINTER(BNCustomCallingConvention),
]
# noinspection PyPep8Naming
def BNCreateCallingConvention(
arch: ctypes.POINTER(BNArchitecture),
name: Optional[str],
cc: ctypes.POINTER(BNCustomCallingConvention)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNCreateCallingConvention(arch, cstr(name), cc)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateComponent
_BNCreateComponent = core.BNCreateComponent
_BNCreateComponent.restype = ctypes.POINTER(BNComponent)
_BNCreateComponent.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNCreateComponent(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNComponent)]:
result = _BNCreateComponent(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateComponentWithName
_BNCreateComponentWithName = core.BNCreateComponentWithName
_BNCreateComponentWithName.restype = ctypes.POINTER(BNComponent)
_BNCreateComponentWithName.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateComponentWithName(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNComponent)]:
result = _BNCreateComponentWithName(view, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateComponentWithParent
_BNCreateComponentWithParent = core.BNCreateComponentWithParent
_BNCreateComponentWithParent.restype = ctypes.POINTER(BNComponent)
_BNCreateComponentWithParent.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateComponentWithParent(
view: ctypes.POINTER(BNBinaryView),
parentGUID: Optional[str]
) -> Optional[ctypes.POINTER(BNComponent)]:
result = _BNCreateComponentWithParent(view, cstr(parentGUID))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateComponentWithParentAndName
_BNCreateComponentWithParentAndName = core.BNCreateComponentWithParentAndName
_BNCreateComponentWithParentAndName.restype = ctypes.POINTER(BNComponent)
_BNCreateComponentWithParentAndName.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateComponentWithParentAndName(
view: ctypes.POINTER(BNBinaryView),
parentGUID: Optional[str],
name: Optional[str]
) -> Optional[ctypes.POINTER(BNComponent)]:
result = _BNCreateComponentWithParentAndName(view, cstr(parentGUID), cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateCustomBinaryView
_BNCreateCustomBinaryView = core.BNCreateCustomBinaryView
_BNCreateCustomBinaryView.restype = ctypes.POINTER(BNBinaryView)
_BNCreateCustomBinaryView.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNCustomBinaryView),
]
# noinspection PyPep8Naming
def BNCreateCustomBinaryView(
name: Optional[str],
file: ctypes.POINTER(BNFileMetadata),
parent: ctypes.POINTER(BNBinaryView),
view: ctypes.POINTER(BNCustomBinaryView)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNCreateCustomBinaryView(cstr(name), file, parent, view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateCustomFlowGraph
_BNCreateCustomFlowGraph = core.BNCreateCustomFlowGraph
_BNCreateCustomFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateCustomFlowGraph.argtypes = [
ctypes.POINTER(BNCustomFlowGraph),
]
# noinspection PyPep8Naming
def BNCreateCustomFlowGraph(
callbacks: ctypes.POINTER(BNCustomFlowGraph)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNCreateCustomFlowGraph(callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateDataBuffer
_BNCreateDataBuffer = core.BNCreateDataBuffer
_BNCreateDataBuffer.restype = ctypes.POINTER(BNDataBuffer)
_BNCreateDataBuffer.argtypes = [
ctypes.c_void_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateDataBuffer(
data: Optional[ctypes.c_void_p],
len: int
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNCreateDataBuffer(data, len)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateDataRenderer
_BNCreateDataRenderer = core.BNCreateDataRenderer
_BNCreateDataRenderer.restype = ctypes.POINTER(BNDataRenderer)
_BNCreateDataRenderer.argtypes = [
ctypes.POINTER(BNCustomDataRenderer),
]
# noinspection PyPep8Naming
def BNCreateDataRenderer(
renderer: ctypes.POINTER(BNCustomDataRenderer)
) -> Optional[ctypes.POINTER(BNDataRenderer)]:
result = _BNCreateDataRenderer(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateDatabase
_BNCreateDatabase = core.BNCreateDatabase
_BNCreateDatabase.restype = ctypes.c_bool
_BNCreateDatabase.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNSaveSettings),
]
# noinspection PyPep8Naming
def BNCreateDatabase(
data: ctypes.POINTER(BNBinaryView),
path: Optional[str],
settings: ctypes.POINTER(BNSaveSettings)
) -> bool:
return _BNCreateDatabase(data, cstr(path), settings)
# -------------------------------------------------------
# _BNCreateDatabaseWithProgress
_BNCreateDatabaseWithProgress = core.BNCreateDatabaseWithProgress
_BNCreateDatabaseWithProgress.restype = ctypes.c_bool
_BNCreateDatabaseWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.POINTER(BNSaveSettings),
]
# noinspection PyPep8Naming
def BNCreateDatabaseWithProgress(
data: ctypes.POINTER(BNBinaryView),
path: Optional[str],
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
settings: ctypes.POINTER(BNSaveSettings)
) -> bool:
return _BNCreateDatabaseWithProgress(data, cstr(path), ctxt, progress, settings)
# -------------------------------------------------------
# _BNCreateDirectory
_BNCreateDirectory = core.BNCreateDirectory
_BNCreateDirectory.restype = ctypes.c_bool
_BNCreateDirectory.argtypes = [
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNCreateDirectory(
path: Optional[str],
createSubdirectories: bool
) -> bool:
return _BNCreateDirectory(cstr(path), createSubdirectories)
# -------------------------------------------------------
# _BNCreateDisassemblySettings
_BNCreateDisassemblySettings = core.BNCreateDisassemblySettings
_BNCreateDisassemblySettings.restype = ctypes.POINTER(BNDisassemblySettings)
_BNCreateDisassemblySettings.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateDisassemblySettings(
) -> Optional[ctypes.POINTER(BNDisassemblySettings)]:
result = _BNCreateDisassemblySettings()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateDisassemblyTextRenderer
_BNCreateDisassemblyTextRenderer = core.BNCreateDisassemblyTextRenderer
_BNCreateDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateDisassemblyTextRenderer.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateDisassemblyTextRenderer(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
result = _BNCreateDisassemblyTextRenderer(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateDownloadProviderInstance
_BNCreateDownloadProviderInstance = core.BNCreateDownloadProviderInstance
_BNCreateDownloadProviderInstance.restype = ctypes.POINTER(BNDownloadInstance)
_BNCreateDownloadProviderInstance.argtypes = [
ctypes.POINTER(BNDownloadProvider),
]
# noinspection PyPep8Naming
def BNCreateDownloadProviderInstance(
provider: ctypes.POINTER(BNDownloadProvider)
) -> Optional[ctypes.POINTER(BNDownloadInstance)]:
result = _BNCreateDownloadProviderInstance(provider)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateEnumerationBuilder
_BNCreateEnumerationBuilder = core.BNCreateEnumerationBuilder
_BNCreateEnumerationBuilder.restype = ctypes.POINTER(BNEnumerationBuilder)
_BNCreateEnumerationBuilder.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateEnumerationBuilder(
) -> Optional[ctypes.POINTER(BNEnumerationBuilder)]:
result = _BNCreateEnumerationBuilder()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateEnumerationBuilderFromEnumeration
_BNCreateEnumerationBuilderFromEnumeration = core.BNCreateEnumerationBuilderFromEnumeration
_BNCreateEnumerationBuilderFromEnumeration.restype = ctypes.POINTER(BNEnumerationBuilder)
_BNCreateEnumerationBuilderFromEnumeration.argtypes = [
ctypes.POINTER(BNEnumeration),
]
# noinspection PyPep8Naming
def BNCreateEnumerationBuilderFromEnumeration(
e: ctypes.POINTER(BNEnumeration)
) -> Optional[ctypes.POINTER(BNEnumerationBuilder)]:
result = _BNCreateEnumerationBuilderFromEnumeration(e)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateEnumerationType
_BNCreateEnumerationType = core.BNCreateEnumerationType
_BNCreateEnumerationType.restype = ctypes.POINTER(BNType)
_BNCreateEnumerationType.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNEnumeration),
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNCreateEnumerationType(
arch: ctypes.POINTER(BNArchitecture),
e: ctypes.POINTER(BNEnumeration),
width: int,
isSigned: ctypes.POINTER(BNBoolWithConfidence)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateEnumerationType(arch, e, width, isSigned)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateEnumerationTypeBuilder
_BNCreateEnumerationTypeBuilder = core.BNCreateEnumerationTypeBuilder
_BNCreateEnumerationTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateEnumerationTypeBuilder.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNEnumeration),
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNCreateEnumerationTypeBuilder(
arch: ctypes.POINTER(BNArchitecture),
e: ctypes.POINTER(BNEnumeration),
width: int,
isSigned: ctypes.POINTER(BNBoolWithConfidence)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateEnumerationTypeBuilder(arch, e, width, isSigned)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateEnumerationTypeBuilderWithBuilder
_BNCreateEnumerationTypeBuilderWithBuilder = core.BNCreateEnumerationTypeBuilderWithBuilder
_BNCreateEnumerationTypeBuilderWithBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateEnumerationTypeBuilderWithBuilder.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNEnumerationBuilder),
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNCreateEnumerationTypeBuilderWithBuilder(
arch: ctypes.POINTER(BNArchitecture),
e: ctypes.POINTER(BNEnumerationBuilder),
width: int,
isSigned: ctypes.POINTER(BNBoolWithConfidence)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateEnumerationTypeBuilderWithBuilder(arch, e, width, isSigned)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateEnumerationTypeOfWidth
_BNCreateEnumerationTypeOfWidth = core.BNCreateEnumerationTypeOfWidth
_BNCreateEnumerationTypeOfWidth.restype = ctypes.POINTER(BNType)
_BNCreateEnumerationTypeOfWidth.argtypes = [
ctypes.POINTER(BNEnumeration),
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNCreateEnumerationTypeOfWidth(
e: ctypes.POINTER(BNEnumeration),
width: int,
isSigned: ctypes.POINTER(BNBoolWithConfidence)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateEnumerationTypeOfWidth(e, width, isSigned)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateFileMetadata
_BNCreateFileMetadata = core.BNCreateFileMetadata
_BNCreateFileMetadata.restype = ctypes.POINTER(BNFileMetadata)
_BNCreateFileMetadata.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateFileMetadata(
) -> Optional[ctypes.POINTER(BNFileMetadata)]:
result = _BNCreateFileMetadata()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateFloatType
_BNCreateFloatType = core.BNCreateFloatType
_BNCreateFloatType.restype = ctypes.POINTER(BNType)
_BNCreateFloatType.argtypes = [
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateFloatType(
width: int,
altName: Optional[str]
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateFloatType(width, cstr(altName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateFloatTypeBuilder
_BNCreateFloatTypeBuilder = core.BNCreateFloatTypeBuilder
_BNCreateFloatTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateFloatTypeBuilder.argtypes = [
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateFloatTypeBuilder(
width: int,
altName: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateFloatTypeBuilder(width, cstr(altName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateFlowGraph
_BNCreateFlowGraph = core.BNCreateFlowGraph
_BNCreateFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateFlowGraph.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateFlowGraph(
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNCreateFlowGraph()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateFlowGraphNode
_BNCreateFlowGraphNode = core.BNCreateFlowGraphNode
_BNCreateFlowGraphNode.restype = ctypes.POINTER(BNFlowGraphNode)
_BNCreateFlowGraphNode.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNCreateFlowGraphNode(
graph: ctypes.POINTER(BNFlowGraph)
) -> Optional[ctypes.POINTER(BNFlowGraphNode)]:
result = _BNCreateFlowGraphNode(graph)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateFunctionGraph
_BNCreateFunctionGraph = core.BNCreateFunctionGraph
_BNCreateFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateFunctionGraph.argtypes = [
ctypes.POINTER(BNFunction),
FunctionGraphTypeEnum,
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateFunctionGraph(
func: ctypes.POINTER(BNFunction),
type: FunctionGraphType,
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNCreateFunctionGraph(func, type, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateFunctionType
_BNCreateFunctionType = core.BNCreateFunctionType
_BNCreateFunctionType.restype = ctypes.POINTER(BNType)
_BNCreateFunctionType.argtypes = [
ctypes.POINTER(BNTypeWithConfidence),
ctypes.POINTER(BNCallingConventionWithConfidence),
ctypes.POINTER(BNFunctionParameter),
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNOffsetWithConfidence),
ctypes.POINTER(ctypes.c_uint),
ctypes.POINTER(BNOffsetWithConfidence),
ctypes.c_ulonglong,
ctypes.POINTER(BNRegisterSetWithConfidence),
NameTypeEnum,
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNCreateFunctionType(
returnValue: ctypes.POINTER(BNTypeWithConfidence),
callingConvention: ctypes.POINTER(BNCallingConventionWithConfidence),
params: ctypes.POINTER(BNFunctionParameter),
paramCount: int,
varArg: ctypes.POINTER(BNBoolWithConfidence),
canReturn: ctypes.POINTER(BNBoolWithConfidence),
stackAdjust: ctypes.POINTER(BNOffsetWithConfidence),
regStackAdjustRegs: ctypes.POINTER(ctypes.c_uint),
regStackAdjustValues: ctypes.POINTER(BNOffsetWithConfidence),
regStackAdjustCount: int,
returnRegs: ctypes.POINTER(BNRegisterSetWithConfidence),
ft: NameType,
pure: ctypes.POINTER(BNBoolWithConfidence)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateFunctionType(returnValue, callingConvention, params, paramCount, varArg, canReturn, stackAdjust, regStackAdjustRegs, regStackAdjustValues, regStackAdjustCount, returnRegs, ft, pure)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateFunctionTypeBuilder
_BNCreateFunctionTypeBuilder = core.BNCreateFunctionTypeBuilder
_BNCreateFunctionTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateFunctionTypeBuilder.argtypes = [
ctypes.POINTER(BNTypeWithConfidence),
ctypes.POINTER(BNCallingConventionWithConfidence),
ctypes.POINTER(BNFunctionParameter),
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNOffsetWithConfidence),
ctypes.POINTER(ctypes.c_uint),
ctypes.POINTER(BNOffsetWithConfidence),
ctypes.c_ulonglong,
ctypes.POINTER(BNRegisterSetWithConfidence),
NameTypeEnum,
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNCreateFunctionTypeBuilder(
returnValue: ctypes.POINTER(BNTypeWithConfidence),
callingConvention: ctypes.POINTER(BNCallingConventionWithConfidence),
params: ctypes.POINTER(BNFunctionParameter),
paramCount: int,
varArg: ctypes.POINTER(BNBoolWithConfidence),
canReturn: ctypes.POINTER(BNBoolWithConfidence),
stackAdjust: ctypes.POINTER(BNOffsetWithConfidence),
regStackAdjustRegs: ctypes.POINTER(ctypes.c_uint),
regStackAdjustValues: ctypes.POINTER(BNOffsetWithConfidence),
regStackAdjustCount: int,
returnRegs: ctypes.POINTER(BNRegisterSetWithConfidence),
ft: NameType,
pure: ctypes.POINTER(BNBoolWithConfidence)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateFunctionTypeBuilder(returnValue, callingConvention, params, paramCount, varArg, canReturn, stackAdjust, regStackAdjustRegs, regStackAdjustValues, regStackAdjustCount, returnRegs, ft, pure)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateHighLevelILDisassemblyTextRenderer
_BNCreateHighLevelILDisassemblyTextRenderer = core.BNCreateHighLevelILDisassemblyTextRenderer
_BNCreateHighLevelILDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateHighLevelILDisassemblyTextRenderer.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateHighLevelILDisassemblyTextRenderer(
func: ctypes.POINTER(BNHighLevelILFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
result = _BNCreateHighLevelILDisassemblyTextRenderer(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateHighLevelILFunction
_BNCreateHighLevelILFunction = core.BNCreateHighLevelILFunction
_BNCreateHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNCreateHighLevelILFunction.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNCreateHighLevelILFunction(
arch: ctypes.POINTER(BNArchitecture),
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNCreateHighLevelILFunction(arch, func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateHighLevelILFunctionGraph
_BNCreateHighLevelILFunctionGraph = core.BNCreateHighLevelILFunctionGraph
_BNCreateHighLevelILFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateHighLevelILFunctionGraph.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateHighLevelILFunctionGraph(
func: ctypes.POINTER(BNHighLevelILFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNCreateHighLevelILFunctionGraph(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateIntegerType
_BNCreateIntegerType = core.BNCreateIntegerType
_BNCreateIntegerType.restype = ctypes.POINTER(BNType)
_BNCreateIntegerType.argtypes = [
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateIntegerType(
width: int,
sign: ctypes.POINTER(BNBoolWithConfidence),
altName: Optional[str]
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateIntegerType(width, sign, cstr(altName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateIntegerTypeBuilder
_BNCreateIntegerTypeBuilder = core.BNCreateIntegerTypeBuilder
_BNCreateIntegerTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateIntegerTypeBuilder.argtypes = [
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateIntegerTypeBuilder(
width: int,
sign: ctypes.POINTER(BNBoolWithConfidence),
altName: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateIntegerTypeBuilder(width, sign, cstr(altName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateKeyValueStore
_BNCreateKeyValueStore = core.BNCreateKeyValueStore
_BNCreateKeyValueStore.restype = ctypes.POINTER(BNKeyValueStore)
_BNCreateKeyValueStore.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateKeyValueStore(
) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
result = _BNCreateKeyValueStore()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateKeyValueStoreFromDataBuffer
_BNCreateKeyValueStoreFromDataBuffer = core.BNCreateKeyValueStoreFromDataBuffer
_BNCreateKeyValueStoreFromDataBuffer.restype = ctypes.POINTER(BNKeyValueStore)
_BNCreateKeyValueStoreFromDataBuffer.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNCreateKeyValueStoreFromDataBuffer(
buffer: ctypes.POINTER(BNDataBuffer)
) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
result = _BNCreateKeyValueStoreFromDataBuffer(buffer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLanguageRepresentationFunction
_BNCreateLanguageRepresentationFunction = core.BNCreateLanguageRepresentationFunction
_BNCreateLanguageRepresentationFunction.restype = ctypes.POINTER(BNLanguageRepresentationFunction)
_BNCreateLanguageRepresentationFunction.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNCreateLanguageRepresentationFunction(
arch: ctypes.POINTER(BNArchitecture),
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNLanguageRepresentationFunction)]:
result = _BNCreateLanguageRepresentationFunction(arch, func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewCursor
_BNCreateLinearViewCursor = core.BNCreateLinearViewCursor
_BNCreateLinearViewCursor.restype = ctypes.POINTER(BNLinearViewCursor)
_BNCreateLinearViewCursor.argtypes = [
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNCreateLinearViewCursor(
root: ctypes.POINTER(BNLinearViewObject)
) -> Optional[ctypes.POINTER(BNLinearViewCursor)]:
result = _BNCreateLinearViewCursor(root)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewDataOnly
_BNCreateLinearViewDataOnly = core.BNCreateLinearViewDataOnly
_BNCreateLinearViewDataOnly.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewDataOnly.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewDataOnly(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewDataOnly(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewDisassembly
_BNCreateLinearViewDisassembly = core.BNCreateLinearViewDisassembly
_BNCreateLinearViewDisassembly.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewDisassembly.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewDisassembly(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewDisassembly(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewHighLevelIL
_BNCreateLinearViewHighLevelIL = core.BNCreateLinearViewHighLevelIL
_BNCreateLinearViewHighLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewHighLevelIL.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewHighLevelIL(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewHighLevelIL(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewHighLevelILSSAForm
_BNCreateLinearViewHighLevelILSSAForm = core.BNCreateLinearViewHighLevelILSSAForm
_BNCreateLinearViewHighLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewHighLevelILSSAForm.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewHighLevelILSSAForm(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewHighLevelILSSAForm(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewLanguageRepresentation
_BNCreateLinearViewLanguageRepresentation = core.BNCreateLinearViewLanguageRepresentation
_BNCreateLinearViewLanguageRepresentation.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLanguageRepresentation.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewLanguageRepresentation(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewLanguageRepresentation(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewLiftedIL
_BNCreateLinearViewLiftedIL = core.BNCreateLinearViewLiftedIL
_BNCreateLinearViewLiftedIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLiftedIL.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewLiftedIL(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewLiftedIL(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewLowLevelIL
_BNCreateLinearViewLowLevelIL = core.BNCreateLinearViewLowLevelIL
_BNCreateLinearViewLowLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLowLevelIL.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewLowLevelIL(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewLowLevelIL(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewLowLevelILSSAForm
_BNCreateLinearViewLowLevelILSSAForm = core.BNCreateLinearViewLowLevelILSSAForm
_BNCreateLinearViewLowLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewLowLevelILSSAForm.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewLowLevelILSSAForm(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewLowLevelILSSAForm(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewMappedMediumLevelIL
_BNCreateLinearViewMappedMediumLevelIL = core.BNCreateLinearViewMappedMediumLevelIL
_BNCreateLinearViewMappedMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMappedMediumLevelIL.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewMappedMediumLevelIL(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewMappedMediumLevelIL(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewMappedMediumLevelILSSAForm
_BNCreateLinearViewMappedMediumLevelILSSAForm = core.BNCreateLinearViewMappedMediumLevelILSSAForm
_BNCreateLinearViewMappedMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMappedMediumLevelILSSAForm.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewMappedMediumLevelILSSAForm(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewMappedMediumLevelILSSAForm(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewMediumLevelIL
_BNCreateLinearViewMediumLevelIL = core.BNCreateLinearViewMediumLevelIL
_BNCreateLinearViewMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMediumLevelIL.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewMediumLevelIL(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewMediumLevelIL(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewMediumLevelILSSAForm
_BNCreateLinearViewMediumLevelILSSAForm = core.BNCreateLinearViewMediumLevelILSSAForm
_BNCreateLinearViewMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewMediumLevelILSSAForm.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewMediumLevelILSSAForm(
view: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewMediumLevelILSSAForm(view, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionDisassembly
_BNCreateLinearViewSingleFunctionDisassembly = core.BNCreateLinearViewSingleFunctionDisassembly
_BNCreateLinearViewSingleFunctionDisassembly.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionDisassembly.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionDisassembly(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionDisassembly(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionHighLevelIL
_BNCreateLinearViewSingleFunctionHighLevelIL = core.BNCreateLinearViewSingleFunctionHighLevelIL
_BNCreateLinearViewSingleFunctionHighLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionHighLevelIL.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionHighLevelIL(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionHighLevelIL(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionHighLevelILSSAForm
_BNCreateLinearViewSingleFunctionHighLevelILSSAForm = core.BNCreateLinearViewSingleFunctionHighLevelILSSAForm
_BNCreateLinearViewSingleFunctionHighLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionHighLevelILSSAForm.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionHighLevelILSSAForm(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionHighLevelILSSAForm(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLanguageRepresentation
_BNCreateLinearViewSingleFunctionLanguageRepresentation = core.BNCreateLinearViewSingleFunctionLanguageRepresentation
_BNCreateLinearViewSingleFunctionLanguageRepresentation.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLanguageRepresentation.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLanguageRepresentation(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionLanguageRepresentation(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLiftedIL
_BNCreateLinearViewSingleFunctionLiftedIL = core.BNCreateLinearViewSingleFunctionLiftedIL
_BNCreateLinearViewSingleFunctionLiftedIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLiftedIL.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLiftedIL(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionLiftedIL(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLowLevelIL
_BNCreateLinearViewSingleFunctionLowLevelIL = core.BNCreateLinearViewSingleFunctionLowLevelIL
_BNCreateLinearViewSingleFunctionLowLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLowLevelIL.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLowLevelIL(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionLowLevelIL(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionLowLevelILSSAForm
_BNCreateLinearViewSingleFunctionLowLevelILSSAForm = core.BNCreateLinearViewSingleFunctionLowLevelILSSAForm
_BNCreateLinearViewSingleFunctionLowLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionLowLevelILSSAForm.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionLowLevelILSSAForm(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionLowLevelILSSAForm(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMappedMediumLevelIL
_BNCreateLinearViewSingleFunctionMappedMediumLevelIL = core.BNCreateLinearViewSingleFunctionMappedMediumLevelIL
_BNCreateLinearViewSingleFunctionMappedMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMappedMediumLevelIL.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMappedMediumLevelIL(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionMappedMediumLevelIL(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm
_BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm = core.BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm
_BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionMappedMediumLevelILSSAForm(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMediumLevelIL
_BNCreateLinearViewSingleFunctionMediumLevelIL = core.BNCreateLinearViewSingleFunctionMediumLevelIL
_BNCreateLinearViewSingleFunctionMediumLevelIL.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMediumLevelIL.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMediumLevelIL(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionMediumLevelIL(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLinearViewSingleFunctionMediumLevelILSSAForm
_BNCreateLinearViewSingleFunctionMediumLevelILSSAForm = core.BNCreateLinearViewSingleFunctionMediumLevelILSSAForm
_BNCreateLinearViewSingleFunctionMediumLevelILSSAForm.restype = ctypes.POINTER(BNLinearViewObject)
_BNCreateLinearViewSingleFunctionMediumLevelILSSAForm.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLinearViewSingleFunctionMediumLevelILSSAForm(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNCreateLinearViewSingleFunctionMediumLevelILSSAForm(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLowLevelILDisassemblyTextRenderer
_BNCreateLowLevelILDisassemblyTextRenderer = core.BNCreateLowLevelILDisassemblyTextRenderer
_BNCreateLowLevelILDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateLowLevelILDisassemblyTextRenderer.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLowLevelILDisassemblyTextRenderer(
func: ctypes.POINTER(BNLowLevelILFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
result = _BNCreateLowLevelILDisassemblyTextRenderer(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLowLevelILFunction
_BNCreateLowLevelILFunction = core.BNCreateLowLevelILFunction
_BNCreateLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNCreateLowLevelILFunction.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNCreateLowLevelILFunction(
arch: ctypes.POINTER(BNArchitecture),
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNCreateLowLevelILFunction(arch, func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateLowLevelILFunctionGraph
_BNCreateLowLevelILFunctionGraph = core.BNCreateLowLevelILFunctionGraph
_BNCreateLowLevelILFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateLowLevelILFunctionGraph.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateLowLevelILFunctionGraph(
func: ctypes.POINTER(BNLowLevelILFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNCreateLowLevelILFunctionGraph(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMediumLevelILDisassemblyTextRenderer
_BNCreateMediumLevelILDisassemblyTextRenderer = core.BNCreateMediumLevelILDisassemblyTextRenderer
_BNCreateMediumLevelILDisassemblyTextRenderer.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNCreateMediumLevelILDisassemblyTextRenderer.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateMediumLevelILDisassemblyTextRenderer(
func: ctypes.POINTER(BNMediumLevelILFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
result = _BNCreateMediumLevelILDisassemblyTextRenderer(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMediumLevelILFunction
_BNCreateMediumLevelILFunction = core.BNCreateMediumLevelILFunction
_BNCreateMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNCreateMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNCreateMediumLevelILFunction(
arch: ctypes.POINTER(BNArchitecture),
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNCreateMediumLevelILFunction(arch, func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMediumLevelILFunctionGraph
_BNCreateMediumLevelILFunctionGraph = core.BNCreateMediumLevelILFunctionGraph
_BNCreateMediumLevelILFunctionGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNCreateMediumLevelILFunctionGraph.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNCreateMediumLevelILFunctionGraph(
func: ctypes.POINTER(BNMediumLevelILFunction),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNCreateMediumLevelILFunctionGraph(func, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataArray
_BNCreateMetadataArray = core.BNCreateMetadataArray
_BNCreateMetadataArray.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataArray.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNMetadata)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateMetadataArray(
data: ctypes.POINTER(ctypes.POINTER(BNMetadata)),
size: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataArray(data, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataBooleanData
_BNCreateMetadataBooleanData = core.BNCreateMetadataBooleanData
_BNCreateMetadataBooleanData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataBooleanData.argtypes = [
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNCreateMetadataBooleanData(
data: bool
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataBooleanData(data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataBooleanListData
_BNCreateMetadataBooleanListData = core.BNCreateMetadataBooleanListData
_BNCreateMetadataBooleanListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataBooleanListData.argtypes = [
ctypes.POINTER(ctypes.c_bool),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateMetadataBooleanListData(
data: ctypes.POINTER(ctypes.c_bool),
size: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataBooleanListData(data, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataDoubleData
_BNCreateMetadataDoubleData = core.BNCreateMetadataDoubleData
_BNCreateMetadataDoubleData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataDoubleData.argtypes = [
ctypes.c_double,
]
# noinspection PyPep8Naming
def BNCreateMetadataDoubleData(
data: float
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataDoubleData(data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataDoubleListData
_BNCreateMetadataDoubleListData = core.BNCreateMetadataDoubleListData
_BNCreateMetadataDoubleListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataDoubleListData.argtypes = [
ctypes.POINTER(ctypes.c_double),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateMetadataDoubleListData(
data: ctypes.POINTER(ctypes.c_double),
size: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataDoubleListData(data, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataOfType
_BNCreateMetadataOfType = core.BNCreateMetadataOfType
_BNCreateMetadataOfType.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataOfType.argtypes = [
MetadataTypeEnum,
]
# noinspection PyPep8Naming
def BNCreateMetadataOfType(
type: MetadataType
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataOfType(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataRawData
_BNCreateMetadataRawData = core.BNCreateMetadataRawData
_BNCreateMetadataRawData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataRawData.argtypes = [
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateMetadataRawData(
data: ctypes.POINTER(ctypes.c_ubyte),
size: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataRawData(data, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataSignedIntegerData
_BNCreateMetadataSignedIntegerData = core.BNCreateMetadataSignedIntegerData
_BNCreateMetadataSignedIntegerData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataSignedIntegerData.argtypes = [
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNCreateMetadataSignedIntegerData(
data: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataSignedIntegerData(data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataSignedIntegerListData
_BNCreateMetadataSignedIntegerListData = core.BNCreateMetadataSignedIntegerListData
_BNCreateMetadataSignedIntegerListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataSignedIntegerListData.argtypes = [
ctypes.POINTER(ctypes.c_longlong),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateMetadataSignedIntegerListData(
data: ctypes.POINTER(ctypes.c_longlong),
size: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataSignedIntegerListData(data, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataStringData
_BNCreateMetadataStringData = core.BNCreateMetadataStringData
_BNCreateMetadataStringData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataStringData.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateMetadataStringData(
data: Optional[str]
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataStringData(cstr(data))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataStringListData
_BNCreateMetadataStringListData = core.BNCreateMetadataStringListData
_BNCreateMetadataStringListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataStringListData.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateMetadataStringListData(
data: ctypes.POINTER(ctypes.c_char_p),
size: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataStringListData(data, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataUnsignedIntegerData
_BNCreateMetadataUnsignedIntegerData = core.BNCreateMetadataUnsignedIntegerData
_BNCreateMetadataUnsignedIntegerData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataUnsignedIntegerData.argtypes = [
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateMetadataUnsignedIntegerData(
data: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataUnsignedIntegerData(data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataUnsignedIntegerListData
_BNCreateMetadataUnsignedIntegerListData = core.BNCreateMetadataUnsignedIntegerListData
_BNCreateMetadataUnsignedIntegerListData.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataUnsignedIntegerListData.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateMetadataUnsignedIntegerListData(
data: ctypes.POINTER(ctypes.c_ulonglong),
size: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataUnsignedIntegerListData(data, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateMetadataValueStore
_BNCreateMetadataValueStore = core.BNCreateMetadataValueStore
_BNCreateMetadataValueStore.restype = ctypes.POINTER(BNMetadata)
_BNCreateMetadataValueStore.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.POINTER(BNMetadata)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateMetadataValueStore(
keys: ctypes.POINTER(ctypes.c_char_p),
values: ctypes.POINTER(ctypes.POINTER(BNMetadata)),
size: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNCreateMetadataValueStore(keys, values, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateNamedType
_BNCreateNamedType = core.BNCreateNamedType
_BNCreateNamedType.restype = ctypes.POINTER(BNNamedTypeReference)
_BNCreateNamedType.argtypes = [
NamedTypeReferenceClassEnum,
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNCreateNamedType(
cls: NamedTypeReferenceClass,
id: Optional[str],
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
result = _BNCreateNamedType(cls, cstr(id), name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateNamedTypeBuilder
_BNCreateNamedTypeBuilder = core.BNCreateNamedTypeBuilder
_BNCreateNamedTypeBuilder.restype = ctypes.POINTER(BNNamedTypeReferenceBuilder)
_BNCreateNamedTypeBuilder.argtypes = [
NamedTypeReferenceClassEnum,
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNCreateNamedTypeBuilder(
cls: NamedTypeReferenceClass,
id: Optional[str],
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNNamedTypeReferenceBuilder)]:
result = _BNCreateNamedTypeBuilder(cls, cstr(id), name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateNamedTypeReference
_BNCreateNamedTypeReference = core.BNCreateNamedTypeReference
_BNCreateNamedTypeReference.restype = ctypes.POINTER(BNType)
_BNCreateNamedTypeReference.argtypes = [
ctypes.POINTER(BNNamedTypeReference),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNCreateNamedTypeReference(
nt: ctypes.POINTER(BNNamedTypeReference),
width: int,
align: int,
cnst: ctypes.POINTER(BNBoolWithConfidence),
vltl: ctypes.POINTER(BNBoolWithConfidence)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateNamedTypeReference(nt, width, align, cnst, vltl)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilder
_BNCreateNamedTypeReferenceBuilder = core.BNCreateNamedTypeReferenceBuilder
_BNCreateNamedTypeReferenceBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilder.argtypes = [
ctypes.POINTER(BNNamedTypeReference),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilder(
nt: ctypes.POINTER(BNNamedTypeReference),
width: int,
align: int,
cnst: ctypes.POINTER(BNBoolWithConfidence),
vltl: ctypes.POINTER(BNBoolWithConfidence)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateNamedTypeReferenceBuilder(nt, width, align, cnst, vltl)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilderFromType
_BNCreateNamedTypeReferenceBuilderFromType = core.BNCreateNamedTypeReferenceBuilderFromType
_BNCreateNamedTypeReferenceBuilderFromType.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilderFromType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilderFromType(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateNamedTypeReferenceBuilderFromType(view, name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilderFromTypeAndId
_BNCreateNamedTypeReferenceBuilderFromTypeAndId = core.BNCreateNamedTypeReferenceBuilderFromTypeAndId
_BNCreateNamedTypeReferenceBuilderFromTypeAndId.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilderFromTypeAndId.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilderFromTypeAndId(
id: Optional[str],
name: ctypes.POINTER(BNQualifiedName),
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateNamedTypeReferenceBuilderFromTypeAndId(cstr(id), name, type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateNamedTypeReferenceBuilderWithBuilder
_BNCreateNamedTypeReferenceBuilderWithBuilder = core.BNCreateNamedTypeReferenceBuilderWithBuilder
_BNCreateNamedTypeReferenceBuilderWithBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateNamedTypeReferenceBuilderWithBuilder.argtypes = [
ctypes.POINTER(BNNamedTypeReferenceBuilder),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceBuilderWithBuilder(
nt: ctypes.POINTER(BNNamedTypeReferenceBuilder),
width: int,
align: int,
cnst: ctypes.POINTER(BNBoolWithConfidence),
vltl: ctypes.POINTER(BNBoolWithConfidence)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateNamedTypeReferenceBuilderWithBuilder(nt, width, align, cnst, vltl)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateNamedTypeReferenceFromType
_BNCreateNamedTypeReferenceFromType = core.BNCreateNamedTypeReferenceFromType
_BNCreateNamedTypeReferenceFromType.restype = ctypes.POINTER(BNType)
_BNCreateNamedTypeReferenceFromType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceFromType(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateNamedTypeReferenceFromType(view, name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateNamedTypeReferenceFromTypeAndId
_BNCreateNamedTypeReferenceFromTypeAndId = core.BNCreateNamedTypeReferenceFromTypeAndId
_BNCreateNamedTypeReferenceFromTypeAndId.restype = ctypes.POINTER(BNType)
_BNCreateNamedTypeReferenceFromTypeAndId.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNCreateNamedTypeReferenceFromTypeAndId(
id: Optional[str],
name: ctypes.POINTER(BNQualifiedName),
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateNamedTypeReferenceFromTypeAndId(cstr(id), name, type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreatePlatform
_BNCreatePlatform = core.BNCreatePlatform
_BNCreatePlatform.restype = ctypes.POINTER(BNPlatform)
_BNCreatePlatform.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreatePlatform(
arch: ctypes.POINTER(BNArchitecture),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNCreatePlatform(arch, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreatePlatformWithTypes
_BNCreatePlatformWithTypes = core.BNCreatePlatformWithTypes
_BNCreatePlatformWithTypes.restype = ctypes.POINTER(BNPlatform)
_BNCreatePlatformWithTypes.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreatePlatformWithTypes(
arch: ctypes.POINTER(BNArchitecture),
name: Optional[str],
typeFile: Optional[str],
includeDirs: ctypes.POINTER(ctypes.c_char_p),
includeDirCount: int
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNCreatePlatformWithTypes(arch, cstr(name), cstr(typeFile), includeDirs, includeDirCount)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreatePointerType
_BNCreatePointerType = core.BNCreatePointerType
_BNCreatePointerType.restype = ctypes.POINTER(BNType)
_BNCreatePointerType.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNTypeWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ReferenceTypeEnum,
]
# noinspection PyPep8Naming
def BNCreatePointerType(
arch: ctypes.POINTER(BNArchitecture),
type: ctypes.POINTER(BNTypeWithConfidence),
cnst: ctypes.POINTER(BNBoolWithConfidence),
vltl: ctypes.POINTER(BNBoolWithConfidence),
refType: ReferenceType
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreatePointerType(arch, type, cnst, vltl, refType)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreatePointerTypeBuilder
_BNCreatePointerTypeBuilder = core.BNCreatePointerTypeBuilder
_BNCreatePointerTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreatePointerTypeBuilder.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNTypeWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ReferenceTypeEnum,
]
# noinspection PyPep8Naming
def BNCreatePointerTypeBuilder(
arch: ctypes.POINTER(BNArchitecture),
type: ctypes.POINTER(BNTypeWithConfidence),
cnst: ctypes.POINTER(BNBoolWithConfidence),
vltl: ctypes.POINTER(BNBoolWithConfidence),
refType: ReferenceType
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreatePointerTypeBuilder(arch, type, cnst, vltl, refType)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreatePointerTypeBuilderOfWidth
_BNCreatePointerTypeBuilderOfWidth = core.BNCreatePointerTypeBuilderOfWidth
_BNCreatePointerTypeBuilderOfWidth.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreatePointerTypeBuilderOfWidth.argtypes = [
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ReferenceTypeEnum,
]
# noinspection PyPep8Naming
def BNCreatePointerTypeBuilderOfWidth(
width: int,
type: ctypes.POINTER(BNTypeWithConfidence),
cnst: ctypes.POINTER(BNBoolWithConfidence),
vltl: ctypes.POINTER(BNBoolWithConfidence),
refType: ReferenceType
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreatePointerTypeBuilderOfWidth(width, type, cnst, vltl, refType)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreatePointerTypeOfWidth
_BNCreatePointerTypeOfWidth = core.BNCreatePointerTypeOfWidth
_BNCreatePointerTypeOfWidth.restype = ctypes.POINTER(BNType)
_BNCreatePointerTypeOfWidth.argtypes = [
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ctypes.POINTER(BNBoolWithConfidence),
ReferenceTypeEnum,
]
# noinspection PyPep8Naming
def BNCreatePointerTypeOfWidth(
width: int,
type: ctypes.POINTER(BNTypeWithConfidence),
cnst: ctypes.POINTER(BNBoolWithConfidence),
vltl: ctypes.POINTER(BNBoolWithConfidence),
refType: ReferenceType
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreatePointerTypeOfWidth(width, type, cnst, vltl, refType)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateProject
_BNCreateProject = core.BNCreateProject
_BNCreateProject.restype = ctypes.POINTER(BNProject)
_BNCreateProject.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateProject(
path: Optional[str],
name: Optional[str]
) -> Optional[ctypes.POINTER(BNProject)]:
result = _BNCreateProject(cstr(path), cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateRelocationHandler
_BNCreateRelocationHandler = core.BNCreateRelocationHandler
_BNCreateRelocationHandler.restype = ctypes.POINTER(BNRelocationHandler)
_BNCreateRelocationHandler.argtypes = [
ctypes.POINTER(BNCustomRelocationHandler),
]
# noinspection PyPep8Naming
def BNCreateRelocationHandler(
handler: ctypes.POINTER(BNCustomRelocationHandler)
) -> Optional[ctypes.POINTER(BNRelocationHandler)]:
result = _BNCreateRelocationHandler(handler)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateReportCollection
_BNCreateReportCollection = core.BNCreateReportCollection
_BNCreateReportCollection.restype = ctypes.POINTER(BNReportCollection)
_BNCreateReportCollection.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateReportCollection(
) -> Optional[ctypes.POINTER(BNReportCollection)]:
result = _BNCreateReportCollection()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateRepositoryManager
_BNCreateRepositoryManager = core.BNCreateRepositoryManager
_BNCreateRepositoryManager.restype = ctypes.POINTER(BNRepositoryManager)
_BNCreateRepositoryManager.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateRepositoryManager(
enabledPluginsPath: Optional[str]
) -> Optional[ctypes.POINTER(BNRepositoryManager)]:
result = _BNCreateRepositoryManager(cstr(enabledPluginsPath))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateSaveSettings
_BNCreateSaveSettings = core.BNCreateSaveSettings
_BNCreateSaveSettings.restype = ctypes.POINTER(BNSaveSettings)
_BNCreateSaveSettings.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateSaveSettings(
) -> Optional[ctypes.POINTER(BNSaveSettings)]:
result = _BNCreateSaveSettings()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateScriptingProviderInstance
_BNCreateScriptingProviderInstance = core.BNCreateScriptingProviderInstance
_BNCreateScriptingProviderInstance.restype = ctypes.POINTER(BNScriptingInstance)
_BNCreateScriptingProviderInstance.argtypes = [
ctypes.POINTER(BNScriptingProvider),
]
# noinspection PyPep8Naming
def BNCreateScriptingProviderInstance(
provider: ctypes.POINTER(BNScriptingProvider)
) -> Optional[ctypes.POINTER(BNScriptingInstance)]:
result = _BNCreateScriptingProviderInstance(provider)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateSegment
_BNCreateSegment = core.BNCreateSegment
_BNCreateSegment.restype = ctypes.POINTER(BNSegment)
_BNCreateSegment.argtypes = [
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNCreateSegment(
start: int,
length: int,
dataOffset: int,
dataLength: int,
flags: int,
autoDefined: bool
) -> Optional[ctypes.POINTER(BNSegment)]:
result = _BNCreateSegment(start, length, dataOffset, dataLength, flags, autoDefined)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateSettings
_BNCreateSettings = core.BNCreateSettings
_BNCreateSettings.restype = ctypes.POINTER(BNSettings)
_BNCreateSettings.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateSettings(
schemaId: Optional[str]
) -> Optional[ctypes.POINTER(BNSettings)]:
result = _BNCreateSettings(cstr(schemaId))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateSnapshotedView
_BNCreateSnapshotedView = core.BNCreateSnapshotedView
_BNCreateSnapshotedView.restype = ctypes.c_bool
_BNCreateSnapshotedView.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateSnapshotedView(
data: ctypes.POINTER(BNBinaryView),
viewName: Optional[str]
) -> bool:
return _BNCreateSnapshotedView(data, cstr(viewName))
# -------------------------------------------------------
# _BNCreateSnapshotedViewWithProgress
_BNCreateSnapshotedViewWithProgress = core.BNCreateSnapshotedViewWithProgress
_BNCreateSnapshotedViewWithProgress.restype = ctypes.c_bool
_BNCreateSnapshotedViewWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNCreateSnapshotedViewWithProgress(
data: ctypes.POINTER(BNBinaryView),
viewName: Optional[str],
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> bool:
return _BNCreateSnapshotedViewWithProgress(data, cstr(viewName), ctxt, progress)
# -------------------------------------------------------
# _BNCreateStructureBuilder
_BNCreateStructureBuilder = core.BNCreateStructureBuilder
_BNCreateStructureBuilder.restype = ctypes.POINTER(BNStructureBuilder)
_BNCreateStructureBuilder.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateStructureBuilder(
) -> Optional[ctypes.POINTER(BNStructureBuilder)]:
result = _BNCreateStructureBuilder()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateStructureBuilderFromStructure
_BNCreateStructureBuilderFromStructure = core.BNCreateStructureBuilderFromStructure
_BNCreateStructureBuilderFromStructure.restype = ctypes.POINTER(BNStructureBuilder)
_BNCreateStructureBuilderFromStructure.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNCreateStructureBuilderFromStructure(
s: ctypes.POINTER(BNStructure)
) -> Optional[ctypes.POINTER(BNStructureBuilder)]:
result = _BNCreateStructureBuilderFromStructure(s)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateStructureBuilderWithOptions
_BNCreateStructureBuilderWithOptions = core.BNCreateStructureBuilderWithOptions
_BNCreateStructureBuilderWithOptions.restype = ctypes.POINTER(BNStructureBuilder)
_BNCreateStructureBuilderWithOptions.argtypes = [
StructureVariantEnum,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNCreateStructureBuilderWithOptions(
type: StructureVariant,
packed: bool
) -> Optional[ctypes.POINTER(BNStructureBuilder)]:
result = _BNCreateStructureBuilderWithOptions(type, packed)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateStructureFromOffsetAccess
_BNCreateStructureFromOffsetAccess = core.BNCreateStructureFromOffsetAccess
_BNCreateStructureFromOffsetAccess.restype = ctypes.POINTER(BNStructure)
_BNCreateStructureFromOffsetAccess.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_bool),
]
# noinspection PyPep8Naming
def BNCreateStructureFromOffsetAccess(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName),
newMember: ctypes.POINTER(ctypes.c_bool)
) -> Optional[ctypes.POINTER(BNStructure)]:
result = _BNCreateStructureFromOffsetAccess(view, name, newMember)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateStructureMemberFromAccess
_BNCreateStructureMemberFromAccess = core.BNCreateStructureMemberFromAccess
_BNCreateStructureMemberFromAccess.restype = BNTypeWithConfidence
_BNCreateStructureMemberFromAccess.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateStructureMemberFromAccess(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName),
offset: int
) -> BNTypeWithConfidence:
return _BNCreateStructureMemberFromAccess(view, name, offset)
# -------------------------------------------------------
# _BNCreateStructureType
_BNCreateStructureType = core.BNCreateStructureType
_BNCreateStructureType.restype = ctypes.POINTER(BNType)
_BNCreateStructureType.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNCreateStructureType(
s: ctypes.POINTER(BNStructure)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateStructureType(s)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateStructureTypeBuilder
_BNCreateStructureTypeBuilder = core.BNCreateStructureTypeBuilder
_BNCreateStructureTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateStructureTypeBuilder.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNCreateStructureTypeBuilder(
s: ctypes.POINTER(BNStructure)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateStructureTypeBuilder(s)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateStructureTypeBuilderWithBuilder
_BNCreateStructureTypeBuilderWithBuilder = core.BNCreateStructureTypeBuilderWithBuilder
_BNCreateStructureTypeBuilderWithBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateStructureTypeBuilderWithBuilder.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNCreateStructureTypeBuilderWithBuilder(
s: ctypes.POINTER(BNStructureBuilder)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateStructureTypeBuilderWithBuilder(s)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateSymbol
_BNCreateSymbol = core.BNCreateSymbol
_BNCreateSymbol.restype = ctypes.POINTER(BNSymbol)
_BNCreateSymbol.argtypes = [
SymbolTypeEnum,
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_ulonglong,
SymbolBindingEnum,
ctypes.POINTER(BNNameSpace),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateSymbol(
type: SymbolType,
shortName: Optional[str],
fullName: Optional[str],
rawName: Optional[str],
addr: int,
binding: SymbolBinding,
nameSpace: ctypes.POINTER(BNNameSpace),
ordinal: int
) -> Optional[ctypes.POINTER(BNSymbol)]:
result = _BNCreateSymbol(type, cstr(shortName), cstr(fullName), cstr(rawName), addr, binding, nameSpace, ordinal)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateSymbolQueue
_BNCreateSymbolQueue = core.BNCreateSymbolQueue
_BNCreateSymbolQueue.restype = ctypes.POINTER(BNSymbolQueue)
_BNCreateSymbolQueue.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateSymbolQueue(
) -> Optional[ctypes.POINTER(BNSymbolQueue)]:
result = _BNCreateSymbolQueue()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateTag
_BNCreateTag = core.BNCreateTag
_BNCreateTag.restype = ctypes.POINTER(BNTag)
_BNCreateTag.argtypes = [
ctypes.POINTER(BNTagType),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateTag(
type: ctypes.POINTER(BNTagType),
data: Optional[str]
) -> Optional[ctypes.POINTER(BNTag)]:
result = _BNCreateTag(type, cstr(data))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateTagType
_BNCreateTagType = core.BNCreateTagType
_BNCreateTagType.restype = ctypes.POINTER(BNTagType)
_BNCreateTagType.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNCreateTagType(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNTagType)]:
result = _BNCreateTagType(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateTemporaryFile
_BNCreateTemporaryFile = core.BNCreateTemporaryFile
_BNCreateTemporaryFile.restype = ctypes.POINTER(BNTemporaryFile)
_BNCreateTemporaryFile.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateTemporaryFile(
) -> Optional[ctypes.POINTER(BNTemporaryFile)]:
result = _BNCreateTemporaryFile()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateTemporaryFileWithContents
_BNCreateTemporaryFileWithContents = core.BNCreateTemporaryFileWithContents
_BNCreateTemporaryFileWithContents.restype = ctypes.POINTER(BNTemporaryFile)
_BNCreateTemporaryFileWithContents.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNCreateTemporaryFileWithContents(
data: ctypes.POINTER(BNDataBuffer)
) -> Optional[ctypes.POINTER(BNTemporaryFile)]:
result = _BNCreateTemporaryFileWithContents(data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateTypeArchive
_BNCreateTypeArchive = core.BNCreateTypeArchive
_BNCreateTypeArchive.restype = ctypes.POINTER(BNTypeArchive)
_BNCreateTypeArchive.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNCreateTypeArchive(
path: Optional[str],
platform: ctypes.POINTER(BNPlatform)
) -> Optional[ctypes.POINTER(BNTypeArchive)]:
result = _BNCreateTypeArchive(cstr(path), platform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateTypeArchiveWithId
_BNCreateTypeArchiveWithId = core.BNCreateTypeArchiveWithId
_BNCreateTypeArchiveWithId.restype = ctypes.POINTER(BNTypeArchive)
_BNCreateTypeArchiveWithId.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNPlatform),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateTypeArchiveWithId(
path: Optional[str],
platform: ctypes.POINTER(BNPlatform),
id: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeArchive)]:
result = _BNCreateTypeArchiveWithId(cstr(path), platform, cstr(id))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateTypeBuilderFromType
_BNCreateTypeBuilderFromType = core.BNCreateTypeBuilderFromType
_BNCreateTypeBuilderFromType.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateTypeBuilderFromType.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNCreateTypeBuilderFromType(
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateTypeBuilderFromType(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateUserFunction
_BNCreateUserFunction = core.BNCreateUserFunction
_BNCreateUserFunction.restype = ctypes.POINTER(BNFunction)
_BNCreateUserFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNPlatform),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNCreateUserFunction(
view: ctypes.POINTER(BNBinaryView),
platform: ctypes.POINTER(BNPlatform),
addr: int
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNCreateUserFunction(view, platform, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateUserStackVariable
_BNCreateUserStackVariable = core.BNCreateUserStackVariable
_BNCreateUserStackVariable.restype = None
_BNCreateUserStackVariable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_longlong,
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateUserStackVariable(
func: ctypes.POINTER(BNFunction),
offset: int,
type: ctypes.POINTER(BNTypeWithConfidence),
name: Optional[str]
) -> None:
return _BNCreateUserStackVariable(func, offset, type, cstr(name))
# -------------------------------------------------------
# _BNCreateUserVariable
_BNCreateUserVariable = core.BNCreateUserVariable
_BNCreateUserVariable.restype = None
_BNCreateUserVariable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNCreateUserVariable(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable),
type: ctypes.POINTER(BNTypeWithConfidence),
name: Optional[str],
ignoreDisjointUses: bool
) -> None:
return _BNCreateUserVariable(func, var, type, cstr(name), ignoreDisjointUses)
# -------------------------------------------------------
# _BNCreateVoidType
_BNCreateVoidType = core.BNCreateVoidType
_BNCreateVoidType.restype = ctypes.POINTER(BNType)
_BNCreateVoidType.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateVoidType(
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateVoidType()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateVoidTypeBuilder
_BNCreateVoidTypeBuilder = core.BNCreateVoidTypeBuilder
_BNCreateVoidTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateVoidTypeBuilder.argtypes = [
]
# noinspection PyPep8Naming
def BNCreateVoidTypeBuilder(
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateVoidTypeBuilder()
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateWebsocketProviderClient
_BNCreateWebsocketProviderClient = core.BNCreateWebsocketProviderClient
_BNCreateWebsocketProviderClient.restype = ctypes.POINTER(BNWebsocketClient)
_BNCreateWebsocketProviderClient.argtypes = [
ctypes.POINTER(BNWebsocketProvider),
]
# noinspection PyPep8Naming
def BNCreateWebsocketProviderClient(
provider: ctypes.POINTER(BNWebsocketProvider)
) -> Optional[ctypes.POINTER(BNWebsocketClient)]:
result = _BNCreateWebsocketProviderClient(provider)
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateWideCharType
_BNCreateWideCharType = core.BNCreateWideCharType
_BNCreateWideCharType.restype = ctypes.POINTER(BNType)
_BNCreateWideCharType.argtypes = [
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateWideCharType(
width: int,
altName: Optional[str]
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNCreateWideCharType(width, cstr(altName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateWideCharTypeBuilder
_BNCreateWideCharTypeBuilder = core.BNCreateWideCharTypeBuilder
_BNCreateWideCharTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNCreateWideCharTypeBuilder.argtypes = [
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateWideCharTypeBuilder(
width: int,
altName: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNCreateWideCharTypeBuilder(width, cstr(altName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNCreateWorkflow
_BNCreateWorkflow = core.BNCreateWorkflow
_BNCreateWorkflow.restype = ctypes.POINTER(BNWorkflow)
_BNCreateWorkflow.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNCreateWorkflow(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNWorkflow)]:
result = _BNCreateWorkflow(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNDataBufferToBase64
_BNDataBufferToBase64 = core.BNDataBufferToBase64
_BNDataBufferToBase64.restype = ctypes.POINTER(ctypes.c_byte)
_BNDataBufferToBase64.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNDataBufferToBase64(
buf: ctypes.POINTER(BNDataBuffer)
) -> Optional[Optional[str]]:
result = _BNDataBufferToBase64(buf)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNDataBufferToEscapedString
_BNDataBufferToEscapedString = core.BNDataBufferToEscapedString
_BNDataBufferToEscapedString.restype = ctypes.POINTER(ctypes.c_byte)
_BNDataBufferToEscapedString.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNDataBufferToEscapedString(
buf: ctypes.POINTER(BNDataBuffer),
nullTerminates: bool
) -> Optional[Optional[str]]:
result = _BNDataBufferToEscapedString(buf, nullTerminates)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNDatabaseHasGlobal
_BNDatabaseHasGlobal = core.BNDatabaseHasGlobal
_BNDatabaseHasGlobal.restype = ctypes.c_int
_BNDatabaseHasGlobal.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNDatabaseHasGlobal(
database: ctypes.POINTER(BNDatabase),
key: Optional[str]
) -> int:
return _BNDatabaseHasGlobal(database, cstr(key))
# -------------------------------------------------------
# _BNDatabaseReloadConnection
_BNDatabaseReloadConnection = core.BNDatabaseReloadConnection
_BNDatabaseReloadConnection.restype = None
_BNDatabaseReloadConnection.argtypes = [
ctypes.POINTER(BNDatabase),
]
# noinspection PyPep8Naming
def BNDatabaseReloadConnection(
database: ctypes.POINTER(BNDatabase)
) -> None:
return _BNDatabaseReloadConnection(database)
# -------------------------------------------------------
# _BNDeauthenticateEnterpriseServer
_BNDeauthenticateEnterpriseServer = core.BNDeauthenticateEnterpriseServer
_BNDeauthenticateEnterpriseServer.restype = ctypes.c_bool
_BNDeauthenticateEnterpriseServer.argtypes = [
]
# noinspection PyPep8Naming
def BNDeauthenticateEnterpriseServer(
) -> bool:
return _BNDeauthenticateEnterpriseServer()
# -------------------------------------------------------
# _BNDecode
_BNDecode = core.BNDecode
_BNDecode.restype = ctypes.c_bool
_BNDecode.argtypes = [
ctypes.POINTER(BNTransform),
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(BNTransformParameter),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNDecode(
xform: ctypes.POINTER(BNTransform),
input: ctypes.POINTER(BNDataBuffer),
output: ctypes.POINTER(BNDataBuffer),
params: ctypes.POINTER(BNTransformParameter),
paramCount: int
) -> bool:
return _BNDecode(xform, input, output, params, paramCount)
# -------------------------------------------------------
# _BNDecodeBase64
_BNDecodeBase64 = core.BNDecodeBase64
_BNDecodeBase64.restype = ctypes.POINTER(BNDataBuffer)
_BNDecodeBase64.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNDecodeBase64(
str: Optional[str]
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNDecodeBase64(cstr(str))
if not result:
return None
return result
# -------------------------------------------------------
# _BNDecodeEscapedString
_BNDecodeEscapedString = core.BNDecodeEscapedString
_BNDecodeEscapedString.restype = ctypes.POINTER(BNDataBuffer)
_BNDecodeEscapedString.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNDecodeEscapedString(
str: Optional[str]
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNDecodeEscapedString(cstr(str))
if not result:
return None
return result
# -------------------------------------------------------
# _BNDefineAnalysisType
_BNDefineAnalysisType = core.BNDefineAnalysisType
_BNDefineAnalysisType.restype = BNQualifiedName
_BNDefineAnalysisType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNDefineAnalysisType(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str],
defaultName: ctypes.POINTER(BNQualifiedName),
type: ctypes.POINTER(BNType)
) -> BNQualifiedName:
return _BNDefineAnalysisType(view, cstr(id), defaultName, type)
# -------------------------------------------------------
# _BNDefineAnalysisTypes
_BNDefineAnalysisTypes = core.BNDefineAnalysisTypes
_BNDefineAnalysisTypes.restype = ctypes.c_ulonglong
_BNDefineAnalysisTypes.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedNameTypeAndId),
ctypes.c_ulonglong,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
]
# noinspection PyPep8Naming
def BNDefineAnalysisTypes(
view: ctypes.POINTER(BNBinaryView),
types: ctypes.POINTER(BNQualifiedNameTypeAndId),
count: int,
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
progressContext: Optional[ctypes.c_void_p],
resultIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
resultNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName))
) -> int:
return _BNDefineAnalysisTypes(view, types, count, progress, progressContext, resultIds, resultNames)
# -------------------------------------------------------
# _BNDefineAutoSymbol
_BNDefineAutoSymbol = core.BNDefineAutoSymbol
_BNDefineAutoSymbol.restype = None
_BNDefineAutoSymbol.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNDefineAutoSymbol(
view: ctypes.POINTER(BNBinaryView),
sym: ctypes.POINTER(BNSymbol)
) -> None:
return _BNDefineAutoSymbol(view, sym)
# -------------------------------------------------------
# _BNDefineAutoSymbolAndVariableOrFunction
_BNDefineAutoSymbolAndVariableOrFunction = core.BNDefineAutoSymbolAndVariableOrFunction
_BNDefineAutoSymbolAndVariableOrFunction.restype = ctypes.POINTER(BNSymbol)
_BNDefineAutoSymbolAndVariableOrFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNSymbol),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNDefineAutoSymbolAndVariableOrFunction(
view: ctypes.POINTER(BNBinaryView),
platform: ctypes.POINTER(BNPlatform),
sym: ctypes.POINTER(BNSymbol),
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNSymbol)]:
result = _BNDefineAutoSymbolAndVariableOrFunction(view, platform, sym, type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNDefineDataVariable
_BNDefineDataVariable = core.BNDefineDataVariable
_BNDefineDataVariable.restype = None
_BNDefineDataVariable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeWithConfidence),
]
# noinspection PyPep8Naming
def BNDefineDataVariable(
view: ctypes.POINTER(BNBinaryView),
addr: int,
type: ctypes.POINTER(BNTypeWithConfidence)
) -> None:
return _BNDefineDataVariable(view, addr, type)
# -------------------------------------------------------
# _BNDefineImportedFunction
_BNDefineImportedFunction = core.BNDefineImportedFunction
_BNDefineImportedFunction.restype = None
_BNDefineImportedFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNSymbol),
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNDefineImportedFunction(
view: ctypes.POINTER(BNBinaryView),
importAddressSym: ctypes.POINTER(BNSymbol),
func: ctypes.POINTER(BNFunction),
type: ctypes.POINTER(BNType)
) -> None:
return _BNDefineImportedFunction(view, importAddressSym, func, type)
# -------------------------------------------------------
# _BNDefineRelocation
_BNDefineRelocation = core.BNDefineRelocation
_BNDefineRelocation.restype = None
_BNDefineRelocation.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNRelocationInfo),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNDefineRelocation(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
info: ctypes.POINTER(BNRelocationInfo),
target: int,
reloc: int
) -> None:
return _BNDefineRelocation(view, arch, info, target, reloc)
# -------------------------------------------------------
# _BNDefineSymbolRelocation
_BNDefineSymbolRelocation = core.BNDefineSymbolRelocation
_BNDefineSymbolRelocation.restype = None
_BNDefineSymbolRelocation.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNRelocationInfo),
ctypes.POINTER(BNSymbol),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNDefineSymbolRelocation(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
info: ctypes.POINTER(BNRelocationInfo),
target: ctypes.POINTER(BNSymbol),
reloc: int
) -> None:
return _BNDefineSymbolRelocation(view, arch, info, target, reloc)
# -------------------------------------------------------
# _BNDefineUserAnalysisType
_BNDefineUserAnalysisType = core.BNDefineUserAnalysisType
_BNDefineUserAnalysisType.restype = None
_BNDefineUserAnalysisType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNDefineUserAnalysisType(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName),
type: ctypes.POINTER(BNType)
) -> None:
return _BNDefineUserAnalysisType(view, name, type)
# -------------------------------------------------------
# _BNDefineUserAnalysisTypes
_BNDefineUserAnalysisTypes = core.BNDefineUserAnalysisTypes
_BNDefineUserAnalysisTypes.restype = None
_BNDefineUserAnalysisTypes.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedNameAndType),
ctypes.c_ulonglong,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNDefineUserAnalysisTypes(
view: ctypes.POINTER(BNBinaryView),
types: ctypes.POINTER(BNQualifiedNameAndType),
count: int,
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
progressContext: Optional[ctypes.c_void_p]
) -> None:
return _BNDefineUserAnalysisTypes(view, types, count, progress, progressContext)
# -------------------------------------------------------
# _BNDefineUserDataVariable
_BNDefineUserDataVariable = core.BNDefineUserDataVariable
_BNDefineUserDataVariable.restype = None
_BNDefineUserDataVariable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeWithConfidence),
]
# noinspection PyPep8Naming
def BNDefineUserDataVariable(
view: ctypes.POINTER(BNBinaryView),
addr: int,
type: ctypes.POINTER(BNTypeWithConfidence)
) -> None:
return _BNDefineUserDataVariable(view, addr, type)
# -------------------------------------------------------
# _BNDefineUserSymbol
_BNDefineUserSymbol = core.BNDefineUserSymbol
_BNDefineUserSymbol.restype = None
_BNDefineUserSymbol.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNDefineUserSymbol(
view: ctypes.POINTER(BNBinaryView),
sym: ctypes.POINTER(BNSymbol)
) -> None:
return _BNDefineUserSymbol(view, sym)
# -------------------------------------------------------
# _BNDeleteAutoStackVariable
_BNDeleteAutoStackVariable = core.BNDeleteAutoStackVariable
_BNDeleteAutoStackVariable.restype = None
_BNDeleteAutoStackVariable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNDeleteAutoStackVariable(
func: ctypes.POINTER(BNFunction),
offset: int
) -> None:
return _BNDeleteAutoStackVariable(func, offset)
# -------------------------------------------------------
# _BNDeleteDirectory
_BNDeleteDirectory = core.BNDeleteDirectory
_BNDeleteDirectory.restype = ctypes.c_bool
_BNDeleteDirectory.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNDeleteDirectory(
path: Optional[str]
) -> bool:
return _BNDeleteDirectory(cstr(path))
# -------------------------------------------------------
# _BNDeleteFile
_BNDeleteFile = core.BNDeleteFile
_BNDeleteFile.restype = ctypes.c_bool
_BNDeleteFile.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNDeleteFile(
path: Optional[str]
) -> bool:
return _BNDeleteFile(cstr(path))
# -------------------------------------------------------
# _BNDeleteSecretsProviderData
_BNDeleteSecretsProviderData = core.BNDeleteSecretsProviderData
_BNDeleteSecretsProviderData.restype = ctypes.c_bool
_BNDeleteSecretsProviderData.argtypes = [
ctypes.POINTER(BNSecretsProvider),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNDeleteSecretsProviderData(
provider: ctypes.POINTER(BNSecretsProvider),
key: Optional[str]
) -> bool:
return _BNDeleteSecretsProviderData(provider, cstr(key))
# -------------------------------------------------------
# _BNDeleteTypeArchiveType
_BNDeleteTypeArchiveType = core.BNDeleteTypeArchiveType
_BNDeleteTypeArchiveType.restype = ctypes.c_bool
_BNDeleteTypeArchiveType.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNDeleteTypeArchiveType(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str]
) -> bool:
return _BNDeleteTypeArchiveType(archive, cstr(id))
# -------------------------------------------------------
# _BNDeleteUserStackVariable
_BNDeleteUserStackVariable = core.BNDeleteUserStackVariable
_BNDeleteUserStackVariable.restype = None
_BNDeleteUserStackVariable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNDeleteUserStackVariable(
func: ctypes.POINTER(BNFunction),
offset: int
) -> None:
return _BNDeleteUserStackVariable(func, offset)
# -------------------------------------------------------
# _BNDeleteUserVariable
_BNDeleteUserVariable = core.BNDeleteUserVariable
_BNDeleteUserVariable.restype = None
_BNDeleteUserVariable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNDeleteUserVariable(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable)
) -> None:
return _BNDeleteUserVariable(func, var)
# -------------------------------------------------------
# _BNDemangleGNU3
_BNDemangleGNU3 = core.BNDemangleGNU3
_BNDemangleGNU3.restype = ctypes.c_bool
_BNDemangleGNU3.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNDemangleGNU3(
arch: ctypes.POINTER(BNArchitecture),
mangledName: Optional[str],
outType: ctypes.POINTER(ctypes.POINTER(BNType)),
outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong),
simplify: bool
) -> bool:
return _BNDemangleGNU3(arch, cstr(mangledName), outType, outVarName, outVarNameElements, simplify)
# -------------------------------------------------------
# _BNDemangleGNU3WithOptions
_BNDemangleGNU3WithOptions = core.BNDemangleGNU3WithOptions
_BNDemangleGNU3WithOptions.restype = ctypes.c_bool
_BNDemangleGNU3WithOptions.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNDemangleGNU3WithOptions(
arch: ctypes.POINTER(BNArchitecture),
mangledName: Optional[str],
outType: ctypes.POINTER(ctypes.POINTER(BNType)),
outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong),
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNDemangleGNU3WithOptions(arch, cstr(mangledName), outType, outVarName, outVarNameElements, view)
# -------------------------------------------------------
# _BNDemangleMS
_BNDemangleMS = core.BNDemangleMS
_BNDemangleMS.restype = ctypes.c_bool
_BNDemangleMS.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNDemangleMS(
arch: ctypes.POINTER(BNArchitecture),
mangledName: Optional[str],
outType: ctypes.POINTER(ctypes.POINTER(BNType)),
outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong),
simplify: bool
) -> bool:
return _BNDemangleMS(arch, cstr(mangledName), outType, outVarName, outVarNameElements, simplify)
# -------------------------------------------------------
# _BNDemangleMSPlatform
_BNDemangleMSPlatform = core.BNDemangleMSPlatform
_BNDemangleMSPlatform.restype = ctypes.c_bool
_BNDemangleMSPlatform.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.c_char_p,
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNDemangleMSPlatform(
platform: ctypes.POINTER(BNPlatform),
mangledName: Optional[str],
outType: ctypes.POINTER(ctypes.POINTER(BNType)),
outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong),
simplify: bool
) -> bool:
return _BNDemangleMSPlatform(platform, cstr(mangledName), outType, outVarName, outVarNameElements, simplify)
# -------------------------------------------------------
# _BNDemangleMSWithOptions
_BNDemangleMSWithOptions = core.BNDemangleMSWithOptions
_BNDemangleMSWithOptions.restype = ctypes.c_bool
_BNDemangleMSWithOptions.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNDemangleMSWithOptions(
arch: ctypes.POINTER(BNArchitecture),
mangledName: Optional[str],
outType: ctypes.POINTER(ctypes.POINTER(BNType)),
outVarName: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
outVarNameElements: ctypes.POINTER(ctypes.c_ulonglong),
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNDemangleMSWithOptions(arch, cstr(mangledName), outType, outVarName, outVarNameElements, view)
# -------------------------------------------------------
# _BNDeserializeSettings
_BNDeserializeSettings = core.BNDeserializeSettings
_BNDeserializeSettings.restype = ctypes.c_bool
_BNDeserializeSettings.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
]
# noinspection PyPep8Naming
def BNDeserializeSettings(
settings: ctypes.POINTER(BNSettings),
contents: Optional[str],
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope
) -> bool:
return _BNDeserializeSettings(settings, cstr(contents), view, scope)
# -------------------------------------------------------
# _BNDestroySymbolQueue
_BNDestroySymbolQueue = core.BNDestroySymbolQueue
_BNDestroySymbolQueue.restype = None
_BNDestroySymbolQueue.argtypes = [
ctypes.POINTER(BNSymbolQueue),
]
# noinspection PyPep8Naming
def BNDestroySymbolQueue(
queue: ctypes.POINTER(BNSymbolQueue)
) -> None:
return _BNDestroySymbolQueue(queue)
# -------------------------------------------------------
# _BNDisablePlugins
_BNDisablePlugins = core.BNDisablePlugins
_BNDisablePlugins.restype = None
_BNDisablePlugins.argtypes = [
]
# noinspection PyPep8Naming
def BNDisablePlugins(
) -> None:
return _BNDisablePlugins()
# -------------------------------------------------------
# _BNDisassemblyTextRendererHasDataFlow
_BNDisassemblyTextRendererHasDataFlow = core.BNDisassemblyTextRendererHasDataFlow
_BNDisassemblyTextRendererHasDataFlow.restype = ctypes.c_bool
_BNDisassemblyTextRendererHasDataFlow.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNDisassemblyTextRendererHasDataFlow(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> bool:
return _BNDisassemblyTextRendererHasDataFlow(renderer)
# -------------------------------------------------------
# _BNDisassemblyTextRendererWrapComment
_BNDisassemblyTextRendererWrapComment = core.BNDisassemblyTextRendererWrapComment
_BNDisassemblyTextRendererWrapComment.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNDisassemblyTextRendererWrapComment.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.POINTER(BNDisassemblyTextLine),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_char_p,
ctypes.c_bool,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNDisassemblyTextRendererWrapComment(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
inLine: ctypes.POINTER(BNDisassemblyTextLine),
outLineCount: ctypes.POINTER(ctypes.c_ulonglong),
comment: Optional[str],
hasAutoAnnotations: bool,
leadingSpaces: Optional[str],
indentSpaces: Optional[str]
) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
result = _BNDisassemblyTextRendererWrapComment(renderer, inLine, outLineCount, cstr(comment), hasAutoAnnotations, cstr(leadingSpaces), cstr(indentSpaces))
if not result:
return None
return result
# -------------------------------------------------------
# _BNDisconnectWebsocketClient
_BNDisconnectWebsocketClient = core.BNDisconnectWebsocketClient
_BNDisconnectWebsocketClient.restype = ctypes.c_bool
_BNDisconnectWebsocketClient.argtypes = [
ctypes.POINTER(BNWebsocketClient),
]
# noinspection PyPep8Naming
def BNDisconnectWebsocketClient(
client: ctypes.POINTER(BNWebsocketClient)
) -> bool:
return _BNDisconnectWebsocketClient(client)
# -------------------------------------------------------
# _BNDuplicateDataBuffer
_BNDuplicateDataBuffer = core.BNDuplicateDataBuffer
_BNDuplicateDataBuffer.restype = ctypes.POINTER(BNDataBuffer)
_BNDuplicateDataBuffer.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNDuplicateDataBuffer(
buf: ctypes.POINTER(BNDataBuffer)
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNDuplicateDataBuffer(buf)
if not result:
return None
return result
# -------------------------------------------------------
# _BNDuplicateDisassemblySettings
_BNDuplicateDisassemblySettings = core.BNDuplicateDisassemblySettings
_BNDuplicateDisassemblySettings.restype = ctypes.POINTER(BNDisassemblySettings)
_BNDuplicateDisassemblySettings.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNDuplicateDisassemblySettings(
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNDisassemblySettings)]:
result = _BNDuplicateDisassemblySettings(settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNDuplicateEnumerationBuilder
_BNDuplicateEnumerationBuilder = core.BNDuplicateEnumerationBuilder
_BNDuplicateEnumerationBuilder.restype = ctypes.POINTER(BNEnumerationBuilder)
_BNDuplicateEnumerationBuilder.argtypes = [
ctypes.POINTER(BNEnumerationBuilder),
]
# noinspection PyPep8Naming
def BNDuplicateEnumerationBuilder(
e: ctypes.POINTER(BNEnumerationBuilder)
) -> Optional[ctypes.POINTER(BNEnumerationBuilder)]:
result = _BNDuplicateEnumerationBuilder(e)
if not result:
return None
return result
# -------------------------------------------------------
# _BNDuplicateLinearViewCursor
_BNDuplicateLinearViewCursor = core.BNDuplicateLinearViewCursor
_BNDuplicateLinearViewCursor.restype = ctypes.POINTER(BNLinearViewCursor)
_BNDuplicateLinearViewCursor.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNDuplicateLinearViewCursor(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> Optional[ctypes.POINTER(BNLinearViewCursor)]:
result = _BNDuplicateLinearViewCursor(cursor)
if not result:
return None
return result
# -------------------------------------------------------
# _BNDuplicateStructureBuilder
_BNDuplicateStructureBuilder = core.BNDuplicateStructureBuilder
_BNDuplicateStructureBuilder.restype = ctypes.POINTER(BNStructureBuilder)
_BNDuplicateStructureBuilder.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNDuplicateStructureBuilder(
s: ctypes.POINTER(BNStructureBuilder)
) -> Optional[ctypes.POINTER(BNStructureBuilder)]:
result = _BNDuplicateStructureBuilder(s)
if not result:
return None
return result
# -------------------------------------------------------
# _BNDuplicateType
_BNDuplicateType = core.BNDuplicateType
_BNDuplicateType.restype = ctypes.POINTER(BNType)
_BNDuplicateType.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNDuplicateType(
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNDuplicateType(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNDuplicateTypeBuilder
_BNDuplicateTypeBuilder = core.BNDuplicateTypeBuilder
_BNDuplicateTypeBuilder.restype = ctypes.POINTER(BNTypeBuilder)
_BNDuplicateTypeBuilder.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNDuplicateTypeBuilder(
type: ctypes.POINTER(BNTypeBuilder)
) -> Optional[ctypes.POINTER(BNTypeBuilder)]:
result = _BNDuplicateTypeBuilder(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNDuplicateTypeContainer
_BNDuplicateTypeContainer = core.BNDuplicateTypeContainer
_BNDuplicateTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNDuplicateTypeContainer.argtypes = [
ctypes.POINTER(BNTypeContainer),
]
# noinspection PyPep8Naming
def BNDuplicateTypeContainer(
container: ctypes.POINTER(BNTypeContainer)
) -> Optional[ctypes.POINTER(BNTypeContainer)]:
result = _BNDuplicateTypeContainer(container)
if not result:
return None
return result
# -------------------------------------------------------
# _BNDuplicateTypeLibrary
_BNDuplicateTypeLibrary = core.BNDuplicateTypeLibrary
_BNDuplicateTypeLibrary.restype = ctypes.POINTER(BNTypeLibrary)
_BNDuplicateTypeLibrary.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNDuplicateTypeLibrary(
lib: ctypes.POINTER(BNTypeLibrary)
) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
result = _BNDuplicateTypeLibrary(lib)
if not result:
return None
return result
# -------------------------------------------------------
# _BNEncode
_BNEncode = core.BNEncode
_BNEncode.restype = ctypes.c_bool
_BNEncode.argtypes = [
ctypes.POINTER(BNTransform),
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(BNTransformParameter),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNEncode(
xform: ctypes.POINTER(BNTransform),
input: ctypes.POINTER(BNDataBuffer),
output: ctypes.POINTER(BNDataBuffer),
params: ctypes.POINTER(BNTransformParameter),
paramCount: int
) -> bool:
return _BNEncode(xform, input, output, params, paramCount)
# -------------------------------------------------------
# _BNEndBulkModifySymbols
_BNEndBulkModifySymbols = core.BNEndBulkModifySymbols
_BNEndBulkModifySymbols.restype = None
_BNEndBulkModifySymbols.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNEndBulkModifySymbols(
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNEndBulkModifySymbols(view)
# -------------------------------------------------------
# _BNEndKeyValueStoreNamespace
_BNEndKeyValueStoreNamespace = core.BNEndKeyValueStoreNamespace
_BNEndKeyValueStoreNamespace.restype = None
_BNEndKeyValueStoreNamespace.argtypes = [
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNEndKeyValueStoreNamespace(
store: ctypes.POINTER(BNKeyValueStore)
) -> None:
return _BNEndKeyValueStoreNamespace(store)
# -------------------------------------------------------
# _BNEscapeTypeName
_BNEscapeTypeName = core.BNEscapeTypeName
_BNEscapeTypeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNEscapeTypeName.argtypes = [
ctypes.c_char_p,
TokenEscapingTypeEnum,
]
# noinspection PyPep8Naming
def BNEscapeTypeName(
name: Optional[str],
escaping: TokenEscapingType
) -> Optional[Optional[str]]:
result = _BNEscapeTypeName(cstr(name), escaping)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNExecuteMainThreadAction
_BNExecuteMainThreadAction = core.BNExecuteMainThreadAction
_BNExecuteMainThreadAction.restype = None
_BNExecuteMainThreadAction.argtypes = [
ctypes.POINTER(BNMainThreadAction),
]
# noinspection PyPep8Naming
def BNExecuteMainThreadAction(
action: ctypes.POINTER(BNMainThreadAction)
) -> None:
return _BNExecuteMainThreadAction(action)
# -------------------------------------------------------
# _BNExecuteOnMainThread
_BNExecuteOnMainThread = core.BNExecuteOnMainThread
_BNExecuteOnMainThread.restype = ctypes.POINTER(BNMainThreadAction)
_BNExecuteOnMainThread.argtypes = [
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
]
# noinspection PyPep8Naming
def BNExecuteOnMainThread(
ctxt: Optional[ctypes.c_void_p],
func: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
) -> Optional[ctypes.POINTER(BNMainThreadAction)]:
result = _BNExecuteOnMainThread(ctxt, func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNExecuteOnMainThreadAndWait
_BNExecuteOnMainThreadAndWait = core.BNExecuteOnMainThreadAndWait
_BNExecuteOnMainThreadAndWait.restype = None
_BNExecuteOnMainThreadAndWait.argtypes = [
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
]
# noinspection PyPep8Naming
def BNExecuteOnMainThreadAndWait(
ctxt: Optional[ctypes.c_void_p],
func: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
) -> None:
return _BNExecuteOnMainThreadAndWait(ctxt, func)
# -------------------------------------------------------
# _BNExecuteScriptInput
_BNExecuteScriptInput = core.BNExecuteScriptInput
_BNExecuteScriptInput.restype = ScriptingProviderExecuteResultEnum
_BNExecuteScriptInput.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNExecuteScriptInput(
instance: ctypes.POINTER(BNScriptingInstance),
input: Optional[str]
) -> ScriptingProviderExecuteResult:
return _BNExecuteScriptInput(instance, cstr(input))
# -------------------------------------------------------
# _BNExecuteScriptInputFromFilename
_BNExecuteScriptInputFromFilename = core.BNExecuteScriptInputFromFilename
_BNExecuteScriptInputFromFilename.restype = ScriptingProviderExecuteResultEnum
_BNExecuteScriptInputFromFilename.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNExecuteScriptInputFromFilename(
instance: ctypes.POINTER(BNScriptingInstance),
filename: Optional[str]
) -> ScriptingProviderExecuteResult:
return _BNExecuteScriptInputFromFilename(instance, cstr(filename))
# -------------------------------------------------------
# _BNExecuteWorkerProcess
_BNExecuteWorkerProcess = core.BNExecuteWorkerProcess
_BNExecuteWorkerProcess.restype = ctypes.c_bool
_BNExecuteWorkerProcess.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_bool,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNExecuteWorkerProcess(
path: Optional[str],
args: ctypes.POINTER(ctypes.c_char_p),
input: ctypes.POINTER(BNDataBuffer),
output: ctypes.POINTER(ctypes.c_char_p),
error: ctypes.POINTER(ctypes.c_char_p),
stdoutIsText: bool,
stderrIsText: bool
) -> bool:
return _BNExecuteWorkerProcess(cstr(path), args, input, output, error, stdoutIsText, stderrIsText)
# -------------------------------------------------------
# _BNExternalLibraryGetBackingFile
_BNExternalLibraryGetBackingFile = core.BNExternalLibraryGetBackingFile
_BNExternalLibraryGetBackingFile.restype = ctypes.POINTER(BNProjectFile)
_BNExternalLibraryGetBackingFile.argtypes = [
ctypes.POINTER(BNExternalLibrary),
]
# noinspection PyPep8Naming
def BNExternalLibraryGetBackingFile(
lib: ctypes.POINTER(BNExternalLibrary)
) -> Optional[ctypes.POINTER(BNProjectFile)]:
result = _BNExternalLibraryGetBackingFile(lib)
if not result:
return None
return result
# -------------------------------------------------------
# _BNExternalLibraryGetName
_BNExternalLibraryGetName = core.BNExternalLibraryGetName
_BNExternalLibraryGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNExternalLibraryGetName.argtypes = [
ctypes.POINTER(BNExternalLibrary),
]
# noinspection PyPep8Naming
def BNExternalLibraryGetName(
lib: ctypes.POINTER(BNExternalLibrary)
) -> Optional[Optional[str]]:
result = _BNExternalLibraryGetName(lib)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNExternalLibrarySetBackingFile
_BNExternalLibrarySetBackingFile = core.BNExternalLibrarySetBackingFile
_BNExternalLibrarySetBackingFile.restype = None
_BNExternalLibrarySetBackingFile.argtypes = [
ctypes.POINTER(BNExternalLibrary),
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNExternalLibrarySetBackingFile(
lib: ctypes.POINTER(BNExternalLibrary),
file: ctypes.POINTER(BNProjectFile)
) -> None:
return _BNExternalLibrarySetBackingFile(lib, file)
# -------------------------------------------------------
# _BNExternalLocationGetExternalLibrary
_BNExternalLocationGetExternalLibrary = core.BNExternalLocationGetExternalLibrary
_BNExternalLocationGetExternalLibrary.restype = ctypes.POINTER(BNExternalLibrary)
_BNExternalLocationGetExternalLibrary.argtypes = [
ctypes.POINTER(BNExternalLocation),
]
# noinspection PyPep8Naming
def BNExternalLocationGetExternalLibrary(
loc: ctypes.POINTER(BNExternalLocation)
) -> Optional[ctypes.POINTER(BNExternalLibrary)]:
result = _BNExternalLocationGetExternalLibrary(loc)
if not result:
return None
return result
# -------------------------------------------------------
# _BNExternalLocationGetSourceSymbol
_BNExternalLocationGetSourceSymbol = core.BNExternalLocationGetSourceSymbol
_BNExternalLocationGetSourceSymbol.restype = ctypes.POINTER(BNSymbol)
_BNExternalLocationGetSourceSymbol.argtypes = [
ctypes.POINTER(BNExternalLocation),
]
# noinspection PyPep8Naming
def BNExternalLocationGetSourceSymbol(
loc: ctypes.POINTER(BNExternalLocation)
) -> Optional[ctypes.POINTER(BNSymbol)]:
result = _BNExternalLocationGetSourceSymbol(loc)
if not result:
return None
return result
# -------------------------------------------------------
# _BNExternalLocationGetTargetAddress
_BNExternalLocationGetTargetAddress = core.BNExternalLocationGetTargetAddress
_BNExternalLocationGetTargetAddress.restype = ctypes.c_ulonglong
_BNExternalLocationGetTargetAddress.argtypes = [
ctypes.POINTER(BNExternalLocation),
]
# noinspection PyPep8Naming
def BNExternalLocationGetTargetAddress(
loc: ctypes.POINTER(BNExternalLocation)
) -> int:
return _BNExternalLocationGetTargetAddress(loc)
# -------------------------------------------------------
# _BNExternalLocationGetTargetSymbol
_BNExternalLocationGetTargetSymbol = core.BNExternalLocationGetTargetSymbol
_BNExternalLocationGetTargetSymbol.restype = ctypes.POINTER(ctypes.c_byte)
_BNExternalLocationGetTargetSymbol.argtypes = [
ctypes.POINTER(BNExternalLocation),
]
# noinspection PyPep8Naming
def BNExternalLocationGetTargetSymbol(
loc: ctypes.POINTER(BNExternalLocation)
) -> Optional[Optional[str]]:
result = _BNExternalLocationGetTargetSymbol(loc)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNExternalLocationHasTargetAddress
_BNExternalLocationHasTargetAddress = core.BNExternalLocationHasTargetAddress
_BNExternalLocationHasTargetAddress.restype = ctypes.c_bool
_BNExternalLocationHasTargetAddress.argtypes = [
ctypes.POINTER(BNExternalLocation),
]
# noinspection PyPep8Naming
def BNExternalLocationHasTargetAddress(
loc: ctypes.POINTER(BNExternalLocation)
) -> bool:
return _BNExternalLocationHasTargetAddress(loc)
# -------------------------------------------------------
# _BNExternalLocationHasTargetSymbol
_BNExternalLocationHasTargetSymbol = core.BNExternalLocationHasTargetSymbol
_BNExternalLocationHasTargetSymbol.restype = ctypes.c_bool
_BNExternalLocationHasTargetSymbol.argtypes = [
ctypes.POINTER(BNExternalLocation),
]
# noinspection PyPep8Naming
def BNExternalLocationHasTargetSymbol(
loc: ctypes.POINTER(BNExternalLocation)
) -> bool:
return _BNExternalLocationHasTargetSymbol(loc)
# -------------------------------------------------------
# _BNExternalLocationSetExternalLibrary
_BNExternalLocationSetExternalLibrary = core.BNExternalLocationSetExternalLibrary
_BNExternalLocationSetExternalLibrary.restype = None
_BNExternalLocationSetExternalLibrary.argtypes = [
ctypes.POINTER(BNExternalLocation),
ctypes.POINTER(BNExternalLibrary),
]
# noinspection PyPep8Naming
def BNExternalLocationSetExternalLibrary(
loc: ctypes.POINTER(BNExternalLocation),
library: ctypes.POINTER(BNExternalLibrary)
) -> None:
return _BNExternalLocationSetExternalLibrary(loc, library)
# -------------------------------------------------------
# _BNExternalLocationSetTargetAddress
_BNExternalLocationSetTargetAddress = core.BNExternalLocationSetTargetAddress
_BNExternalLocationSetTargetAddress.restype = ctypes.c_bool
_BNExternalLocationSetTargetAddress.argtypes = [
ctypes.POINTER(BNExternalLocation),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNExternalLocationSetTargetAddress(
loc: ctypes.POINTER(BNExternalLocation),
address: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNExternalLocationSetTargetAddress(loc, address)
# -------------------------------------------------------
# _BNExternalLocationSetTargetSymbol
_BNExternalLocationSetTargetSymbol = core.BNExternalLocationSetTargetSymbol
_BNExternalLocationSetTargetSymbol.restype = ctypes.c_bool
_BNExternalLocationSetTargetSymbol.argtypes = [
ctypes.POINTER(BNExternalLocation),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNExternalLocationSetTargetSymbol(
loc: ctypes.POINTER(BNExternalLocation),
symbol: Optional[str]
) -> bool:
return _BNExternalLocationSetTargetSymbol(loc, cstr(symbol))
# -------------------------------------------------------
# _BNFileMetadataGetSessionId
_BNFileMetadataGetSessionId = core.BNFileMetadataGetSessionId
_BNFileMetadataGetSessionId.restype = ctypes.c_ulonglong
_BNFileMetadataGetSessionId.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNFileMetadataGetSessionId(
file: ctypes.POINTER(BNFileMetadata)
) -> int:
return _BNFileMetadataGetSessionId(file)
# -------------------------------------------------------
# _BNFileSize
_BNFileSize = core.BNFileSize
_BNFileSize.restype = ctypes.c_bool
_BNFileSize.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNFileSize(
path: Optional[str],
size: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNFileSize(cstr(path), size)
# -------------------------------------------------------
# _BNFinalizeArchitectureHook
_BNFinalizeArchitectureHook = core.BNFinalizeArchitectureHook
_BNFinalizeArchitectureHook.restype = None
_BNFinalizeArchitectureHook.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNFinalizeArchitectureHook(
base: ctypes.POINTER(BNArchitecture)
) -> None:
return _BNFinalizeArchitectureHook(base)
# -------------------------------------------------------
# _BNFinalizeEnumerationBuilder
_BNFinalizeEnumerationBuilder = core.BNFinalizeEnumerationBuilder
_BNFinalizeEnumerationBuilder.restype = ctypes.POINTER(BNEnumeration)
_BNFinalizeEnumerationBuilder.argtypes = [
ctypes.POINTER(BNEnumerationBuilder),
]
# noinspection PyPep8Naming
def BNFinalizeEnumerationBuilder(
e: ctypes.POINTER(BNEnumerationBuilder)
) -> Optional[ctypes.POINTER(BNEnumeration)]:
result = _BNFinalizeEnumerationBuilder(e)
if not result:
return None
return result
# -------------------------------------------------------
# _BNFinalizeHighLevelILFunction
_BNFinalizeHighLevelILFunction = core.BNFinalizeHighLevelILFunction
_BNFinalizeHighLevelILFunction.restype = None
_BNFinalizeHighLevelILFunction.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNFinalizeHighLevelILFunction(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> None:
return _BNFinalizeHighLevelILFunction(func)
# -------------------------------------------------------
# _BNFinalizeLowLevelILFunction
_BNFinalizeLowLevelILFunction = core.BNFinalizeLowLevelILFunction
_BNFinalizeLowLevelILFunction.restype = None
_BNFinalizeLowLevelILFunction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNFinalizeLowLevelILFunction(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> None:
return _BNFinalizeLowLevelILFunction(func)
# -------------------------------------------------------
# _BNFinalizeMediumLevelILFunction
_BNFinalizeMediumLevelILFunction = core.BNFinalizeMediumLevelILFunction
_BNFinalizeMediumLevelILFunction.restype = None
_BNFinalizeMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNFinalizeMediumLevelILFunction(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> None:
return _BNFinalizeMediumLevelILFunction(func)
# -------------------------------------------------------
# _BNFinalizeNamedTypeReferenceBuilder
_BNFinalizeNamedTypeReferenceBuilder = core.BNFinalizeNamedTypeReferenceBuilder
_BNFinalizeNamedTypeReferenceBuilder.restype = ctypes.POINTER(BNNamedTypeReference)
_BNFinalizeNamedTypeReferenceBuilder.argtypes = [
ctypes.POINTER(BNNamedTypeReferenceBuilder),
]
# noinspection PyPep8Naming
def BNFinalizeNamedTypeReferenceBuilder(
s: ctypes.POINTER(BNNamedTypeReferenceBuilder)
) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
result = _BNFinalizeNamedTypeReferenceBuilder(s)
if not result:
return None
return result
# -------------------------------------------------------
# _BNFinalizeStructureBuilder
_BNFinalizeStructureBuilder = core.BNFinalizeStructureBuilder
_BNFinalizeStructureBuilder.restype = ctypes.POINTER(BNStructure)
_BNFinalizeStructureBuilder.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNFinalizeStructureBuilder(
s: ctypes.POINTER(BNStructureBuilder)
) -> Optional[ctypes.POINTER(BNStructure)]:
result = _BNFinalizeStructureBuilder(s)
if not result:
return None
return result
# -------------------------------------------------------
# _BNFinalizeTypeBuilder
_BNFinalizeTypeBuilder = core.BNFinalizeTypeBuilder
_BNFinalizeTypeBuilder.restype = ctypes.POINTER(BNType)
_BNFinalizeTypeBuilder.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNFinalizeTypeBuilder(
type: ctypes.POINTER(BNTypeBuilder)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNFinalizeTypeBuilder(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNFinalizeTypeLibrary
_BNFinalizeTypeLibrary = core.BNFinalizeTypeLibrary
_BNFinalizeTypeLibrary.restype = ctypes.c_bool
_BNFinalizeTypeLibrary.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNFinalizeTypeLibrary(
lib: ctypes.POINTER(BNTypeLibrary)
) -> bool:
return _BNFinalizeTypeLibrary(lib)
# -------------------------------------------------------
# _BNFindAllConstantWithProgress
_BNFindAllConstantWithProgress = core.BNFindAllConstantWithProgress
_BNFindAllConstantWithProgress.restype = ctypes.c_bool
_BNFindAllConstantWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(BNDisassemblySettings),
FunctionGraphTypeEnum,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNLinearDisassemblyLine)),
]
# noinspection PyPep8Naming
def BNFindAllConstantWithProgress(
view: ctypes.POINTER(BNBinaryView),
start: int,
end: int,
constant: int,
settings: ctypes.POINTER(BNDisassemblySettings),
graph: FunctionGraphType,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
matchCtxt: Optional[ctypes.c_void_p],
matchCallback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNLinearDisassemblyLine))
) -> bool:
return _BNFindAllConstantWithProgress(view, start, end, constant, settings, graph, ctxt, progress, matchCtxt, matchCallback)
# -------------------------------------------------------
# _BNFindAllDataWithProgress
_BNFindAllDataWithProgress = core.BNFindAllDataWithProgress
_BNFindAllDataWithProgress.restype = ctypes.c_bool
_BNFindAllDataWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(BNDataBuffer),
FindFlagEnum,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer)),
]
# noinspection PyPep8Naming
def BNFindAllDataWithProgress(
view: ctypes.POINTER(BNBinaryView),
start: int,
end: int,
data: ctypes.POINTER(BNDataBuffer),
flags: FindFlag,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
matchCtxt: Optional[ctypes.c_void_p],
matchCallback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer))
) -> bool:
return _BNFindAllDataWithProgress(view, start, end, data, flags, ctxt, progress, matchCtxt, matchCallback)
# -------------------------------------------------------
# _BNFindAllTextWithProgress
_BNFindAllTextWithProgress = core.BNFindAllTextWithProgress
_BNFindAllTextWithProgress.restype = ctypes.c_bool
_BNFindAllTextWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_char_p,
ctypes.POINTER(BNDisassemblySettings),
FindFlagEnum,
FunctionGraphTypeEnum,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_char_p, ctypes.POINTER(BNLinearDisassemblyLine)),
]
# noinspection PyPep8Naming
def BNFindAllTextWithProgress(
view: ctypes.POINTER(BNBinaryView),
start: int,
end: int,
data: Optional[str],
settings: ctypes.POINTER(BNDisassemblySettings),
flags: FindFlag,
graph: FunctionGraphType,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
matchCtxt: Optional[ctypes.c_void_p],
matchCallback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_char_p, ctypes.POINTER(BNLinearDisassemblyLine))
) -> bool:
return _BNFindAllTextWithProgress(view, start, end, cstr(data), settings, flags, graph, ctxt, progress, matchCtxt, matchCallback)
# -------------------------------------------------------
# _BNFindNextConstant
_BNFindNextConstant = core.BNFindNextConstant
_BNFindNextConstant.restype = ctypes.c_bool
_BNFindNextConstant.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNDisassemblySettings),
FunctionGraphTypeEnum,
]
# noinspection PyPep8Naming
def BNFindNextConstant(
view: ctypes.POINTER(BNBinaryView),
start: int,
constant: int,
result: ctypes.POINTER(ctypes.c_ulonglong),
settings: ctypes.POINTER(BNDisassemblySettings),
graph: FunctionGraphType
) -> bool:
return _BNFindNextConstant(view, start, constant, result, settings, graph)
# -------------------------------------------------------
# _BNFindNextConstantWithProgress
_BNFindNextConstantWithProgress = core.BNFindNextConstantWithProgress
_BNFindNextConstantWithProgress.restype = ctypes.c_bool
_BNFindNextConstantWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNDisassemblySettings),
FunctionGraphTypeEnum,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNFindNextConstantWithProgress(
view: ctypes.POINTER(BNBinaryView),
start: int,
end: int,
constant: int,
result: ctypes.POINTER(ctypes.c_ulonglong),
settings: ctypes.POINTER(BNDisassemblySettings),
graph: FunctionGraphType,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> bool:
return _BNFindNextConstantWithProgress(view, start, end, constant, result, settings, graph, ctxt, progress)
# -------------------------------------------------------
# _BNFindNextData
_BNFindNextData = core.BNFindNextData
_BNFindNextData.restype = ctypes.c_bool
_BNFindNextData.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(ctypes.c_ulonglong),
FindFlagEnum,
]
# noinspection PyPep8Naming
def BNFindNextData(
view: ctypes.POINTER(BNBinaryView),
start: int,
data: ctypes.POINTER(BNDataBuffer),
result: ctypes.POINTER(ctypes.c_ulonglong),
flags: FindFlag
) -> bool:
return _BNFindNextData(view, start, data, result, flags)
# -------------------------------------------------------
# _BNFindNextDataWithProgress
_BNFindNextDataWithProgress = core.BNFindNextDataWithProgress
_BNFindNextDataWithProgress.restype = ctypes.c_bool
_BNFindNextDataWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(BNDataBuffer),
ctypes.POINTER(ctypes.c_ulonglong),
FindFlagEnum,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNFindNextDataWithProgress(
view: ctypes.POINTER(BNBinaryView),
start: int,
end: int,
data: ctypes.POINTER(BNDataBuffer),
result: ctypes.POINTER(ctypes.c_ulonglong),
flags: FindFlag,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> bool:
return _BNFindNextDataWithProgress(view, start, end, data, result, flags, ctxt, progress)
# -------------------------------------------------------
# _BNFindNextText
_BNFindNextText = core.BNFindNextText
_BNFindNextText.restype = ctypes.c_bool
_BNFindNextText.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNDisassemblySettings),
FindFlagEnum,
FunctionGraphTypeEnum,
]
# noinspection PyPep8Naming
def BNFindNextText(
view: ctypes.POINTER(BNBinaryView),
start: int,
data: Optional[str],
result: ctypes.POINTER(ctypes.c_ulonglong),
settings: ctypes.POINTER(BNDisassemblySettings),
flags: FindFlag,
graph: FunctionGraphType
) -> bool:
return _BNFindNextText(view, start, cstr(data), result, settings, flags, graph)
# -------------------------------------------------------
# _BNFindNextTextWithProgress
_BNFindNextTextWithProgress = core.BNFindNextTextWithProgress
_BNFindNextTextWithProgress.restype = ctypes.c_bool
_BNFindNextTextWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNDisassemblySettings),
FindFlagEnum,
FunctionGraphTypeEnum,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNFindNextTextWithProgress(
view: ctypes.POINTER(BNBinaryView),
start: int,
end: int,
data: Optional[str],
result: ctypes.POINTER(ctypes.c_ulonglong),
settings: ctypes.POINTER(BNDisassemblySettings),
flags: FindFlag,
graph: FunctionGraphType,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> bool:
return _BNFindNextTextWithProgress(view, start, end, cstr(data), result, settings, flags, graph, ctxt, progress)
# -------------------------------------------------------
# _BNFinishBackgroundTask
_BNFinishBackgroundTask = core.BNFinishBackgroundTask
_BNFinishBackgroundTask.restype = None
_BNFinishBackgroundTask.argtypes = [
ctypes.POINTER(BNBackgroundTask),
]
# noinspection PyPep8Naming
def BNFinishBackgroundTask(
task: ctypes.POINTER(BNBackgroundTask)
) -> None:
return _BNFinishBackgroundTask(task)
# -------------------------------------------------------
# _BNFinishPrepareForLayout
_BNFinishPrepareForLayout = core.BNFinishPrepareForLayout
_BNFinishPrepareForLayout.restype = None
_BNFinishPrepareForLayout.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNFinishPrepareForLayout(
graph: ctypes.POINTER(BNFlowGraph)
) -> None:
return _BNFinishPrepareForLayout(graph)
# -------------------------------------------------------
# _BNFlowGraphHasNodes
_BNFlowGraphHasNodes = core.BNFlowGraphHasNodes
_BNFlowGraphHasNodes.restype = ctypes.c_bool
_BNFlowGraphHasNodes.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNFlowGraphHasNodes(
graph: ctypes.POINTER(BNFlowGraph)
) -> bool:
return _BNFlowGraphHasNodes(graph)
# -------------------------------------------------------
# _BNFlowGraphHasUpdates
_BNFlowGraphHasUpdates = core.BNFlowGraphHasUpdates
_BNFlowGraphHasUpdates.restype = ctypes.c_bool
_BNFlowGraphHasUpdates.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNFlowGraphHasUpdates(
graph: ctypes.POINTER(BNFlowGraph)
) -> bool:
return _BNFlowGraphHasUpdates(graph)
# -------------------------------------------------------
# _BNFlowGraphUpdateQueryMode
_BNFlowGraphUpdateQueryMode = core.BNFlowGraphUpdateQueryMode
_BNFlowGraphUpdateQueryMode.restype = ctypes.c_bool
_BNFlowGraphUpdateQueryMode.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNFlowGraphUpdateQueryMode(
graph: ctypes.POINTER(BNFlowGraph)
) -> bool:
return _BNFlowGraphUpdateQueryMode(graph)
# -------------------------------------------------------
# _BNForgetUndoActions
_BNForgetUndoActions = core.BNForgetUndoActions
_BNForgetUndoActions.restype = None
_BNForgetUndoActions.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNForgetUndoActions(
file: ctypes.POINTER(BNFileMetadata),
id: Optional[str]
) -> None:
return _BNForgetUndoActions(file, cstr(id))
# -------------------------------------------------------
# _BNFormatTypeParserParseErrors
_BNFormatTypeParserParseErrors = core.BNFormatTypeParserParseErrors
_BNFormatTypeParserParseErrors.restype = ctypes.POINTER(ctypes.c_byte)
_BNFormatTypeParserParseErrors.argtypes = [
ctypes.POINTER(BNTypeParserError),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFormatTypeParserParseErrors(
errors: ctypes.POINTER(BNTypeParserError),
count: int
) -> Optional[Optional[str]]:
result = _BNFormatTypeParserParseErrors(errors, count)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNFreeActivity
_BNFreeActivity = core.BNFreeActivity
_BNFreeActivity.restype = None
_BNFreeActivity.argtypes = [
ctypes.POINTER(BNActivity),
]
# noinspection PyPep8Naming
def BNFreeActivity(
activity: ctypes.POINTER(BNActivity)
) -> None:
return _BNFreeActivity(activity)
# -------------------------------------------------------
# _BNFreeAddressList
_BNFreeAddressList = core.BNFreeAddressList
_BNFreeAddressList.restype = None
_BNFreeAddressList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNFreeAddressList(
addrs: ctypes.POINTER(ctypes.c_ulonglong)
) -> None:
return _BNFreeAddressList(addrs)
# -------------------------------------------------------
# _BNFreeAddressRanges
_BNFreeAddressRanges = core.BNFreeAddressRanges
_BNFreeAddressRanges.restype = None
_BNFreeAddressRanges.argtypes = [
ctypes.POINTER(BNAddressRange),
]
# noinspection PyPep8Naming
def BNFreeAddressRanges(
ranges: ctypes.POINTER(BNAddressRange)
) -> None:
return _BNFreeAddressRanges(ranges)
# -------------------------------------------------------
# _BNFreeAnalysisCompletionEvent
_BNFreeAnalysisCompletionEvent = core.BNFreeAnalysisCompletionEvent
_BNFreeAnalysisCompletionEvent.restype = None
_BNFreeAnalysisCompletionEvent.argtypes = [
ctypes.POINTER(BNAnalysisCompletionEvent),
]
# noinspection PyPep8Naming
def BNFreeAnalysisCompletionEvent(
event: ctypes.POINTER(BNAnalysisCompletionEvent)
) -> None:
return _BNFreeAnalysisCompletionEvent(event)
# -------------------------------------------------------
# _BNFreeAnalysisContext
_BNFreeAnalysisContext = core.BNFreeAnalysisContext
_BNFreeAnalysisContext.restype = None
_BNFreeAnalysisContext.argtypes = [
ctypes.POINTER(BNAnalysisContext),
]
# noinspection PyPep8Naming
def BNFreeAnalysisContext(
analysisContext: ctypes.POINTER(BNAnalysisContext)
) -> None:
return _BNFreeAnalysisContext(analysisContext)
# -------------------------------------------------------
# _BNFreeAnalysisInfo
_BNFreeAnalysisInfo = core.BNFreeAnalysisInfo
_BNFreeAnalysisInfo.restype = None
_BNFreeAnalysisInfo.argtypes = [
ctypes.POINTER(BNAnalysisInfo),
]
# noinspection PyPep8Naming
def BNFreeAnalysisInfo(
info: ctypes.POINTER(BNAnalysisInfo)
) -> None:
return _BNFreeAnalysisInfo(info)
# -------------------------------------------------------
# _BNFreeAnalysisPerformanceInfo
_BNFreeAnalysisPerformanceInfo = core.BNFreeAnalysisPerformanceInfo
_BNFreeAnalysisPerformanceInfo.restype = None
_BNFreeAnalysisPerformanceInfo.argtypes = [
ctypes.POINTER(BNPerformanceInfo),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeAnalysisPerformanceInfo(
info: ctypes.POINTER(BNPerformanceInfo),
count: int
) -> None:
return _BNFreeAnalysisPerformanceInfo(info, count)
# -------------------------------------------------------
# _BNFreeArchitectureList
_BNFreeArchitectureList = core.BNFreeArchitectureList
_BNFreeArchitectureList.restype = None
_BNFreeArchitectureList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNArchitecture)),
]
# noinspection PyPep8Naming
def BNFreeArchitectureList(
archs: ctypes.POINTER(ctypes.POINTER(BNArchitecture))
) -> None:
return _BNFreeArchitectureList(archs)
# -------------------------------------------------------
# _BNFreeBackgroundTask
_BNFreeBackgroundTask = core.BNFreeBackgroundTask
_BNFreeBackgroundTask.restype = None
_BNFreeBackgroundTask.argtypes = [
ctypes.POINTER(BNBackgroundTask),
]
# noinspection PyPep8Naming
def BNFreeBackgroundTask(
task: ctypes.POINTER(BNBackgroundTask)
) -> None:
return _BNFreeBackgroundTask(task)
# -------------------------------------------------------
# _BNFreeBackgroundTaskList
_BNFreeBackgroundTaskList = core.BNFreeBackgroundTaskList
_BNFreeBackgroundTaskList.restype = None
_BNFreeBackgroundTaskList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNBackgroundTask)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeBackgroundTaskList(
tasks: ctypes.POINTER(ctypes.POINTER(BNBackgroundTask)),
count: int
) -> None:
return _BNFreeBackgroundTaskList(tasks, count)
# -------------------------------------------------------
# _BNFreeBaseStructureList
_BNFreeBaseStructureList = core.BNFreeBaseStructureList
_BNFreeBaseStructureList.restype = None
_BNFreeBaseStructureList.argtypes = [
ctypes.POINTER(BNBaseStructure),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeBaseStructureList(
bases: ctypes.POINTER(BNBaseStructure),
count: int
) -> None:
return _BNFreeBaseStructureList(bases, count)
# -------------------------------------------------------
# _BNFreeBasicBlock
_BNFreeBasicBlock = core.BNFreeBasicBlock
_BNFreeBasicBlock.restype = None
_BNFreeBasicBlock.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNFreeBasicBlock(
block: ctypes.POINTER(BNBasicBlock)
) -> None:
return _BNFreeBasicBlock(block)
# -------------------------------------------------------
# _BNFreeBasicBlockEdgeList
_BNFreeBasicBlockEdgeList = core.BNFreeBasicBlockEdgeList
_BNFreeBasicBlockEdgeList.restype = None
_BNFreeBasicBlockEdgeList.argtypes = [
ctypes.POINTER(BNBasicBlockEdge),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeBasicBlockEdgeList(
edges: ctypes.POINTER(BNBasicBlockEdge),
count: int
) -> None:
return _BNFreeBasicBlockEdgeList(edges, count)
# -------------------------------------------------------
# _BNFreeBasicBlockList
_BNFreeBasicBlockList = core.BNFreeBasicBlockList
_BNFreeBasicBlockList.restype = None
_BNFreeBasicBlockList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNBasicBlock)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeBasicBlockList(
blocks: ctypes.POINTER(ctypes.POINTER(BNBasicBlock)),
count: int
) -> None:
return _BNFreeBasicBlockList(blocks, count)
# -------------------------------------------------------
# _BNFreeBinaryReader
_BNFreeBinaryReader = core.BNFreeBinaryReader
_BNFreeBinaryReader.restype = None
_BNFreeBinaryReader.argtypes = [
ctypes.POINTER(BNBinaryReader),
]
# noinspection PyPep8Naming
def BNFreeBinaryReader(
stream: ctypes.POINTER(BNBinaryReader)
) -> None:
return _BNFreeBinaryReader(stream)
# -------------------------------------------------------
# _BNFreeBinaryView
_BNFreeBinaryView = core.BNFreeBinaryView
_BNFreeBinaryView.restype = None
_BNFreeBinaryView.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNFreeBinaryView(
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNFreeBinaryView(view)
# -------------------------------------------------------
# _BNFreeBinaryViewTypeList
_BNFreeBinaryViewTypeList = core.BNFreeBinaryViewTypeList
_BNFreeBinaryViewTypeList.restype = None
_BNFreeBinaryViewTypeList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNBinaryViewType)),
]
# noinspection PyPep8Naming
def BNFreeBinaryViewTypeList(
types: ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))
) -> None:
return _BNFreeBinaryViewTypeList(types)
# -------------------------------------------------------
# _BNFreeBinaryWriter
_BNFreeBinaryWriter = core.BNFreeBinaryWriter
_BNFreeBinaryWriter.restype = None
_BNFreeBinaryWriter.argtypes = [
ctypes.POINTER(BNBinaryWriter),
]
# noinspection PyPep8Naming
def BNFreeBinaryWriter(
stream: ctypes.POINTER(BNBinaryWriter)
) -> None:
return _BNFreeBinaryWriter(stream)
# -------------------------------------------------------
# _BNFreeCallingConvention
_BNFreeCallingConvention = core.BNFreeCallingConvention
_BNFreeCallingConvention.restype = None
_BNFreeCallingConvention.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNFreeCallingConvention(
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNFreeCallingConvention(cc)
# -------------------------------------------------------
# _BNFreeCallingConventionList
_BNFreeCallingConventionList = core.BNFreeCallingConventionList
_BNFreeCallingConventionList.restype = None
_BNFreeCallingConventionList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNCallingConvention)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeCallingConventionList(
list: ctypes.POINTER(ctypes.POINTER(BNCallingConvention)),
count: int
) -> None:
return _BNFreeCallingConventionList(list, count)
# -------------------------------------------------------
# _BNFreeCodeReferences
_BNFreeCodeReferences = core.BNFreeCodeReferences
_BNFreeCodeReferences.restype = None
_BNFreeCodeReferences.argtypes = [
ctypes.POINTER(BNReferenceSource),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeCodeReferences(
refs: ctypes.POINTER(BNReferenceSource),
count: int
) -> None:
return _BNFreeCodeReferences(refs, count)
# -------------------------------------------------------
# _BNFreeComponent
_BNFreeComponent = core.BNFreeComponent
_BNFreeComponent.restype = None
_BNFreeComponent.argtypes = [
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNFreeComponent(
component: ctypes.POINTER(BNComponent)
) -> None:
return _BNFreeComponent(component)
# -------------------------------------------------------
# _BNFreeComponents
_BNFreeComponents = core.BNFreeComponents
_BNFreeComponents.restype = None
_BNFreeComponents.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNComponent)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeComponents(
components: ctypes.POINTER(ctypes.POINTER(BNComponent)),
count: int
) -> None:
return _BNFreeComponents(components, count)
# -------------------------------------------------------
# _BNFreeConstantReferenceList
_BNFreeConstantReferenceList = core.BNFreeConstantReferenceList
_BNFreeConstantReferenceList.restype = None
_BNFreeConstantReferenceList.argtypes = [
ctypes.POINTER(BNConstantReference),
]
# noinspection PyPep8Naming
def BNFreeConstantReferenceList(
refs: ctypes.POINTER(BNConstantReference)
) -> None:
return _BNFreeConstantReferenceList(refs)
# -------------------------------------------------------
# _BNFreeDataBuffer
_BNFreeDataBuffer = core.BNFreeDataBuffer
_BNFreeDataBuffer.restype = None
_BNFreeDataBuffer.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNFreeDataBuffer(
buf: ctypes.POINTER(BNDataBuffer)
) -> None:
return _BNFreeDataBuffer(buf)
# -------------------------------------------------------
# _BNFreeDataReferences
_BNFreeDataReferences = core.BNFreeDataReferences
_BNFreeDataReferences.restype = None
_BNFreeDataReferences.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNFreeDataReferences(
refs: ctypes.POINTER(ctypes.c_ulonglong)
) -> None:
return _BNFreeDataReferences(refs)
# -------------------------------------------------------
# _BNFreeDataRenderer
_BNFreeDataRenderer = core.BNFreeDataRenderer
_BNFreeDataRenderer.restype = None
_BNFreeDataRenderer.argtypes = [
ctypes.POINTER(BNDataRenderer),
]
# noinspection PyPep8Naming
def BNFreeDataRenderer(
renderer: ctypes.POINTER(BNDataRenderer)
) -> None:
return _BNFreeDataRenderer(renderer)
# -------------------------------------------------------
# _BNFreeDataVariable
_BNFreeDataVariable = core.BNFreeDataVariable
_BNFreeDataVariable.restype = None
_BNFreeDataVariable.argtypes = [
ctypes.POINTER(BNDataVariable),
]
# noinspection PyPep8Naming
def BNFreeDataVariable(
var: ctypes.POINTER(BNDataVariable)
) -> None:
return _BNFreeDataVariable(var)
# -------------------------------------------------------
# _BNFreeDataVariableAndName
_BNFreeDataVariableAndName = core.BNFreeDataVariableAndName
_BNFreeDataVariableAndName.restype = None
_BNFreeDataVariableAndName.argtypes = [
ctypes.POINTER(BNDataVariableAndName),
]
# noinspection PyPep8Naming
def BNFreeDataVariableAndName(
var: ctypes.POINTER(BNDataVariableAndName)
) -> None:
return _BNFreeDataVariableAndName(var)
# -------------------------------------------------------
# _BNFreeDataVariableAndNameAndDebugParserList
_BNFreeDataVariableAndNameAndDebugParserList = core.BNFreeDataVariableAndNameAndDebugParserList
_BNFreeDataVariableAndNameAndDebugParserList.restype = None
_BNFreeDataVariableAndNameAndDebugParserList.argtypes = [
ctypes.POINTER(BNDataVariableAndNameAndDebugParser),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeDataVariableAndNameAndDebugParserList(
vars: ctypes.POINTER(BNDataVariableAndNameAndDebugParser),
count: int
) -> None:
return _BNFreeDataVariableAndNameAndDebugParserList(vars, count)
# -------------------------------------------------------
# _BNFreeDataVariables
_BNFreeDataVariables = core.BNFreeDataVariables
_BNFreeDataVariables.restype = None
_BNFreeDataVariables.argtypes = [
ctypes.POINTER(BNDataVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeDataVariables(
vars: ctypes.POINTER(BNDataVariable),
count: int
) -> None:
return _BNFreeDataVariables(vars, count)
# -------------------------------------------------------
# _BNFreeDataVariablesAndName
_BNFreeDataVariablesAndName = core.BNFreeDataVariablesAndName
_BNFreeDataVariablesAndName.restype = None
_BNFreeDataVariablesAndName.argtypes = [
ctypes.POINTER(BNDataVariableAndName),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeDataVariablesAndName(
vars: ctypes.POINTER(BNDataVariableAndName),
count: int
) -> None:
return _BNFreeDataVariablesAndName(vars, count)
# -------------------------------------------------------
# _BNFreeDatabase
_BNFreeDatabase = core.BNFreeDatabase
_BNFreeDatabase.restype = None
_BNFreeDatabase.argtypes = [
ctypes.POINTER(BNDatabase),
]
# noinspection PyPep8Naming
def BNFreeDatabase(
database: ctypes.POINTER(BNDatabase)
) -> None:
return _BNFreeDatabase(database)
# -------------------------------------------------------
# _BNFreeDebugFunctions
_BNFreeDebugFunctions = core.BNFreeDebugFunctions
_BNFreeDebugFunctions.restype = None
_BNFreeDebugFunctions.argtypes = [
ctypes.POINTER(BNDebugFunctionInfo),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeDebugFunctions(
functions: ctypes.POINTER(BNDebugFunctionInfo),
count: int
) -> None:
return _BNFreeDebugFunctions(functions, count)
# -------------------------------------------------------
# _BNFreeDebugInfoParserList
_BNFreeDebugInfoParserList = core.BNFreeDebugInfoParserList
_BNFreeDebugInfoParserList.restype = None
_BNFreeDebugInfoParserList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeDebugInfoParserList(
parsers: ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser)),
count: int
) -> None:
return _BNFreeDebugInfoParserList(parsers, count)
# -------------------------------------------------------
# _BNFreeDebugInfoParserReference
_BNFreeDebugInfoParserReference = core.BNFreeDebugInfoParserReference
_BNFreeDebugInfoParserReference.restype = None
_BNFreeDebugInfoParserReference.argtypes = [
ctypes.POINTER(BNDebugInfoParser),
]
# noinspection PyPep8Naming
def BNFreeDebugInfoParserReference(
parser: ctypes.POINTER(BNDebugInfoParser)
) -> None:
return _BNFreeDebugInfoParserReference(parser)
# -------------------------------------------------------
# _BNFreeDebugInfoReference
_BNFreeDebugInfoReference = core.BNFreeDebugInfoReference
_BNFreeDebugInfoReference.restype = None
_BNFreeDebugInfoReference.argtypes = [
ctypes.POINTER(BNDebugInfo),
]
# noinspection PyPep8Naming
def BNFreeDebugInfoReference(
debugInfo: ctypes.POINTER(BNDebugInfo)
) -> None:
return _BNFreeDebugInfoReference(debugInfo)
# -------------------------------------------------------
# _BNFreeDebugTypes
_BNFreeDebugTypes = core.BNFreeDebugTypes
_BNFreeDebugTypes.restype = None
_BNFreeDebugTypes.argtypes = [
ctypes.POINTER(BNNameAndType),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeDebugTypes(
types: ctypes.POINTER(BNNameAndType),
count: int
) -> None:
return _BNFreeDebugTypes(types, count)
# -------------------------------------------------------
# _BNFreeDemangledName
_BNFreeDemangledName = core.BNFreeDemangledName
_BNFreeDemangledName.restype = None
_BNFreeDemangledName.argtypes = [
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeDemangledName(
name: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
nameElements: int
) -> None:
return _BNFreeDemangledName(name, nameElements)
# -------------------------------------------------------
# _BNFreeDisassemblySettings
_BNFreeDisassemblySettings = core.BNFreeDisassemblySettings
_BNFreeDisassemblySettings.restype = None
_BNFreeDisassemblySettings.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNFreeDisassemblySettings(
settings: ctypes.POINTER(BNDisassemblySettings)
) -> None:
return _BNFreeDisassemblySettings(settings)
# -------------------------------------------------------
# _BNFreeDisassemblyTextLines
_BNFreeDisassemblyTextLines = core.BNFreeDisassemblyTextLines
_BNFreeDisassemblyTextLines.restype = None
_BNFreeDisassemblyTextLines.argtypes = [
ctypes.POINTER(BNDisassemblyTextLine),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeDisassemblyTextLines(
lines: ctypes.POINTER(BNDisassemblyTextLine),
count: int
) -> None:
return _BNFreeDisassemblyTextLines(lines, count)
# -------------------------------------------------------
# _BNFreeDisassemblyTextRenderer
_BNFreeDisassemblyTextRenderer = core.BNFreeDisassemblyTextRenderer
_BNFreeDisassemblyTextRenderer.restype = None
_BNFreeDisassemblyTextRenderer.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNFreeDisassemblyTextRenderer(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> None:
return _BNFreeDisassemblyTextRenderer(renderer)
# -------------------------------------------------------
# _BNFreeDownloadInstance
_BNFreeDownloadInstance = core.BNFreeDownloadInstance
_BNFreeDownloadInstance.restype = None
_BNFreeDownloadInstance.argtypes = [
ctypes.POINTER(BNDownloadInstance),
]
# noinspection PyPep8Naming
def BNFreeDownloadInstance(
instance: ctypes.POINTER(BNDownloadInstance)
) -> None:
return _BNFreeDownloadInstance(instance)
# -------------------------------------------------------
# _BNFreeDownloadInstanceResponse
_BNFreeDownloadInstanceResponse = core.BNFreeDownloadInstanceResponse
_BNFreeDownloadInstanceResponse.restype = None
_BNFreeDownloadInstanceResponse.argtypes = [
ctypes.POINTER(BNDownloadInstanceResponse),
]
# noinspection PyPep8Naming
def BNFreeDownloadInstanceResponse(
response: ctypes.POINTER(BNDownloadInstanceResponse)
) -> None:
return _BNFreeDownloadInstanceResponse(response)
# -------------------------------------------------------
# _BNFreeDownloadProviderList
_BNFreeDownloadProviderList = core.BNFreeDownloadProviderList
_BNFreeDownloadProviderList.restype = None
_BNFreeDownloadProviderList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNDownloadProvider)),
]
# noinspection PyPep8Naming
def BNFreeDownloadProviderList(
providers: ctypes.POINTER(ctypes.POINTER(BNDownloadProvider))
) -> None:
return _BNFreeDownloadProviderList(providers)
# -------------------------------------------------------
# _BNFreeEnumeration
_BNFreeEnumeration = core.BNFreeEnumeration
_BNFreeEnumeration.restype = None
_BNFreeEnumeration.argtypes = [
ctypes.POINTER(BNEnumeration),
]
# noinspection PyPep8Naming
def BNFreeEnumeration(
e: ctypes.POINTER(BNEnumeration)
) -> None:
return _BNFreeEnumeration(e)
# -------------------------------------------------------
# _BNFreeEnumerationBuilder
_BNFreeEnumerationBuilder = core.BNFreeEnumerationBuilder
_BNFreeEnumerationBuilder.restype = None
_BNFreeEnumerationBuilder.argtypes = [
ctypes.POINTER(BNEnumerationBuilder),
]
# noinspection PyPep8Naming
def BNFreeEnumerationBuilder(
e: ctypes.POINTER(BNEnumerationBuilder)
) -> None:
return _BNFreeEnumerationBuilder(e)
# -------------------------------------------------------
# _BNFreeEnumerationMemberList
_BNFreeEnumerationMemberList = core.BNFreeEnumerationMemberList
_BNFreeEnumerationMemberList.restype = None
_BNFreeEnumerationMemberList.argtypes = [
ctypes.POINTER(BNEnumerationMember),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeEnumerationMemberList(
members: ctypes.POINTER(BNEnumerationMember),
count: int
) -> None:
return _BNFreeEnumerationMemberList(members, count)
# -------------------------------------------------------
# _BNFreeExternalLibrary
_BNFreeExternalLibrary = core.BNFreeExternalLibrary
_BNFreeExternalLibrary.restype = None
_BNFreeExternalLibrary.argtypes = [
ctypes.POINTER(BNExternalLibrary),
]
# noinspection PyPep8Naming
def BNFreeExternalLibrary(
lib: ctypes.POINTER(BNExternalLibrary)
) -> None:
return _BNFreeExternalLibrary(lib)
# -------------------------------------------------------
# _BNFreeExternalLibraryList
_BNFreeExternalLibraryList = core.BNFreeExternalLibraryList
_BNFreeExternalLibraryList.restype = None
_BNFreeExternalLibraryList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNExternalLibrary)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeExternalLibraryList(
libs: ctypes.POINTER(ctypes.POINTER(BNExternalLibrary)),
count: int
) -> None:
return _BNFreeExternalLibraryList(libs, count)
# -------------------------------------------------------
# _BNFreeExternalLocation
_BNFreeExternalLocation = core.BNFreeExternalLocation
_BNFreeExternalLocation.restype = None
_BNFreeExternalLocation.argtypes = [
ctypes.POINTER(BNExternalLocation),
]
# noinspection PyPep8Naming
def BNFreeExternalLocation(
loc: ctypes.POINTER(BNExternalLocation)
) -> None:
return _BNFreeExternalLocation(loc)
# -------------------------------------------------------
# _BNFreeExternalLocationList
_BNFreeExternalLocationList = core.BNFreeExternalLocationList
_BNFreeExternalLocationList.restype = None
_BNFreeExternalLocationList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNExternalLocation)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeExternalLocationList(
locs: ctypes.POINTER(ctypes.POINTER(BNExternalLocation)),
count: int
) -> None:
return _BNFreeExternalLocationList(locs, count)
# -------------------------------------------------------
# _BNFreeFileMetadata
_BNFreeFileMetadata = core.BNFreeFileMetadata
_BNFreeFileMetadata.restype = None
_BNFreeFileMetadata.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNFreeFileMetadata(
file: ctypes.POINTER(BNFileMetadata)
) -> None:
return _BNFreeFileMetadata(file)
# -------------------------------------------------------
# _BNFreeFlagConditionsForSemanticFlagGroup
_BNFreeFlagConditionsForSemanticFlagGroup = core.BNFreeFlagConditionsForSemanticFlagGroup
_BNFreeFlagConditionsForSemanticFlagGroup.restype = None
_BNFreeFlagConditionsForSemanticFlagGroup.argtypes = [
ctypes.POINTER(BNFlagConditionForSemanticClass),
]
# noinspection PyPep8Naming
def BNFreeFlagConditionsForSemanticFlagGroup(
conditions: ctypes.POINTER(BNFlagConditionForSemanticClass)
) -> None:
return _BNFreeFlagConditionsForSemanticFlagGroup(conditions)
# -------------------------------------------------------
# _BNFreeFlowGraph
_BNFreeFlowGraph = core.BNFreeFlowGraph
_BNFreeFlowGraph.restype = None
_BNFreeFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNFreeFlowGraph(
graph: ctypes.POINTER(BNFlowGraph)
) -> None:
return _BNFreeFlowGraph(graph)
# -------------------------------------------------------
# _BNFreeFlowGraphLayoutRequest
_BNFreeFlowGraphLayoutRequest = core.BNFreeFlowGraphLayoutRequest
_BNFreeFlowGraphLayoutRequest.restype = None
_BNFreeFlowGraphLayoutRequest.argtypes = [
ctypes.POINTER(BNFlowGraphLayoutRequest),
]
# noinspection PyPep8Naming
def BNFreeFlowGraphLayoutRequest(
layout: ctypes.POINTER(BNFlowGraphLayoutRequest)
) -> None:
return _BNFreeFlowGraphLayoutRequest(layout)
# -------------------------------------------------------
# _BNFreeFlowGraphNode
_BNFreeFlowGraphNode = core.BNFreeFlowGraphNode
_BNFreeFlowGraphNode.restype = None
_BNFreeFlowGraphNode.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNFreeFlowGraphNode(
node: ctypes.POINTER(BNFlowGraphNode)
) -> None:
return _BNFreeFlowGraphNode(node)
# -------------------------------------------------------
# _BNFreeFlowGraphNodeEdgeList
_BNFreeFlowGraphNodeEdgeList = core.BNFreeFlowGraphNodeEdgeList
_BNFreeFlowGraphNodeEdgeList.restype = None
_BNFreeFlowGraphNodeEdgeList.argtypes = [
ctypes.POINTER(BNFlowGraphEdge),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeFlowGraphNodeEdgeList(
edges: ctypes.POINTER(BNFlowGraphEdge),
count: int
) -> None:
return _BNFreeFlowGraphNodeEdgeList(edges, count)
# -------------------------------------------------------
# _BNFreeFlowGraphNodeList
_BNFreeFlowGraphNodeList = core.BNFreeFlowGraphNodeList
_BNFreeFlowGraphNodeList.restype = None
_BNFreeFlowGraphNodeList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeFlowGraphNodeList(
nodes: ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode)),
count: int
) -> None:
return _BNFreeFlowGraphNodeList(nodes, count)
# -------------------------------------------------------
# _BNFreeFormInputResults
_BNFreeFormInputResults = core.BNFreeFormInputResults
_BNFreeFormInputResults.restype = None
_BNFreeFormInputResults.argtypes = [
ctypes.POINTER(BNFormInputField),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeFormInputResults(
fields: ctypes.POINTER(BNFormInputField),
count: int
) -> None:
return _BNFreeFormInputResults(fields, count)
# -------------------------------------------------------
# _BNFreeFullInfoUpdateChannels
_BNFreeFullInfoUpdateChannels = core.BNFreeFullInfoUpdateChannels
_BNFreeFullInfoUpdateChannels.restype = None
_BNFreeFullInfoUpdateChannels.argtypes = [
ctypes.POINTER(BNUpdateChannelFullInfo),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeFullInfoUpdateChannels(
list: ctypes.POINTER(BNUpdateChannelFullInfo),
count: int
) -> None:
return _BNFreeFullInfoUpdateChannels(list, count)
# -------------------------------------------------------
# _BNFreeFunction
_BNFreeFunction = core.BNFreeFunction
_BNFreeFunction.restype = None
_BNFreeFunction.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNFreeFunction(
func: ctypes.POINTER(BNFunction)
) -> None:
return _BNFreeFunction(func)
# -------------------------------------------------------
# _BNFreeFunctionList
_BNFreeFunctionList = core.BNFreeFunctionList
_BNFreeFunctionList.restype = None
_BNFreeFunctionList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNFunction)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeFunctionList(
funcs: ctypes.POINTER(ctypes.POINTER(BNFunction)),
count: int
) -> None:
return _BNFreeFunctionList(funcs, count)
# -------------------------------------------------------
# _BNFreeHighLevelILFunction
_BNFreeHighLevelILFunction = core.BNFreeHighLevelILFunction
_BNFreeHighLevelILFunction.restype = None
_BNFreeHighLevelILFunction.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNFreeHighLevelILFunction(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> None:
return _BNFreeHighLevelILFunction(func)
# -------------------------------------------------------
# _BNFreeILBranchDependenceList
_BNFreeILBranchDependenceList = core.BNFreeILBranchDependenceList
_BNFreeILBranchDependenceList.restype = None
_BNFreeILBranchDependenceList.argtypes = [
ctypes.POINTER(BNILBranchInstructionAndDependence),
]
# noinspection PyPep8Naming
def BNFreeILBranchDependenceList(
branches: ctypes.POINTER(BNILBranchInstructionAndDependence)
) -> None:
return _BNFreeILBranchDependenceList(branches)
# -------------------------------------------------------
# _BNFreeILInstructionList
_BNFreeILInstructionList = core.BNFreeILInstructionList
_BNFreeILInstructionList.restype = None
_BNFreeILInstructionList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNFreeILInstructionList(
list: ctypes.POINTER(ctypes.c_ulonglong)
) -> None:
return _BNFreeILInstructionList(list)
# -------------------------------------------------------
# _BNFreeILReferences
_BNFreeILReferences = core.BNFreeILReferences
_BNFreeILReferences.restype = None
_BNFreeILReferences.argtypes = [
ctypes.POINTER(BNILReferenceSource),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeILReferences(
refs: ctypes.POINTER(BNILReferenceSource),
count: int
) -> None:
return _BNFreeILReferences(refs, count)
# -------------------------------------------------------
# _BNFreeIndirectBranchList
_BNFreeIndirectBranchList = core.BNFreeIndirectBranchList
_BNFreeIndirectBranchList.restype = None
_BNFreeIndirectBranchList.argtypes = [
ctypes.POINTER(BNIndirectBranchInfo),
]
# noinspection PyPep8Naming
def BNFreeIndirectBranchList(
branches: ctypes.POINTER(BNIndirectBranchInfo)
) -> None:
return _BNFreeIndirectBranchList(branches)
# -------------------------------------------------------
# _BNFreeInheritedStructureMember
_BNFreeInheritedStructureMember = core.BNFreeInheritedStructureMember
_BNFreeInheritedStructureMember.restype = None
_BNFreeInheritedStructureMember.argtypes = [
ctypes.POINTER(BNInheritedStructureMember),
]
# noinspection PyPep8Naming
def BNFreeInheritedStructureMember(
members: ctypes.POINTER(BNInheritedStructureMember)
) -> None:
return _BNFreeInheritedStructureMember(members)
# -------------------------------------------------------
# _BNFreeInheritedStructureMemberList
_BNFreeInheritedStructureMemberList = core.BNFreeInheritedStructureMemberList
_BNFreeInheritedStructureMemberList.restype = None
_BNFreeInheritedStructureMemberList.argtypes = [
ctypes.POINTER(BNInheritedStructureMember),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeInheritedStructureMemberList(
members: ctypes.POINTER(BNInheritedStructureMember),
count: int
) -> None:
return _BNFreeInheritedStructureMemberList(members, count)
# -------------------------------------------------------
# _BNFreeInstructionText
_BNFreeInstructionText = core.BNFreeInstructionText
_BNFreeInstructionText.restype = None
_BNFreeInstructionText.argtypes = [
ctypes.POINTER(BNInstructionTextToken),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeInstructionText(
tokens: ctypes.POINTER(BNInstructionTextToken),
count: int
) -> None:
return _BNFreeInstructionText(tokens, count)
# -------------------------------------------------------
# _BNFreeInstructionTextLines
_BNFreeInstructionTextLines = core.BNFreeInstructionTextLines
_BNFreeInstructionTextLines.restype = None
_BNFreeInstructionTextLines.argtypes = [
ctypes.POINTER(BNInstructionTextLine),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeInstructionTextLines(
lines: ctypes.POINTER(BNInstructionTextLine),
count: int
) -> None:
return _BNFreeInstructionTextLines(lines, count)
# -------------------------------------------------------
# _BNFreeKeyValueStore
_BNFreeKeyValueStore = core.BNFreeKeyValueStore
_BNFreeKeyValueStore.restype = None
_BNFreeKeyValueStore.argtypes = [
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNFreeKeyValueStore(
store: ctypes.POINTER(BNKeyValueStore)
) -> None:
return _BNFreeKeyValueStore(store)
# -------------------------------------------------------
# _BNFreeLLILVariableVersionList
_BNFreeLLILVariableVersionList = core.BNFreeLLILVariableVersionList
_BNFreeLLILVariableVersionList.restype = None
_BNFreeLLILVariableVersionList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNFreeLLILVariableVersionList(
versions: ctypes.POINTER(ctypes.c_ulonglong)
) -> None:
return _BNFreeLLILVariableVersionList(versions)
# -------------------------------------------------------
# _BNFreeLLILVariablesList
_BNFreeLLILVariablesList = core.BNFreeLLILVariablesList
_BNFreeLLILVariablesList.restype = None
_BNFreeLLILVariablesList.argtypes = [
ctypes.POINTER(ctypes.c_uint),
]
# noinspection PyPep8Naming
def BNFreeLLILVariablesList(
vars: ctypes.POINTER(ctypes.c_uint)
) -> None:
return _BNFreeLLILVariablesList(vars)
# -------------------------------------------------------
# _BNFreeLanguageRepresentationFunction
_BNFreeLanguageRepresentationFunction = core.BNFreeLanguageRepresentationFunction
_BNFreeLanguageRepresentationFunction.restype = None
_BNFreeLanguageRepresentationFunction.argtypes = [
ctypes.POINTER(BNLanguageRepresentationFunction),
]
# noinspection PyPep8Naming
def BNFreeLanguageRepresentationFunction(
func: ctypes.POINTER(BNLanguageRepresentationFunction)
) -> None:
return _BNFreeLanguageRepresentationFunction(func)
# -------------------------------------------------------
# _BNFreeLinearDisassemblyLines
_BNFreeLinearDisassemblyLines = core.BNFreeLinearDisassemblyLines
_BNFreeLinearDisassemblyLines.restype = None
_BNFreeLinearDisassemblyLines.argtypes = [
ctypes.POINTER(BNLinearDisassemblyLine),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeLinearDisassemblyLines(
lines: ctypes.POINTER(BNLinearDisassemblyLine),
count: int
) -> None:
return _BNFreeLinearDisassemblyLines(lines, count)
# -------------------------------------------------------
# _BNFreeLinearViewCursor
_BNFreeLinearViewCursor = core.BNFreeLinearViewCursor
_BNFreeLinearViewCursor.restype = None
_BNFreeLinearViewCursor.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNFreeLinearViewCursor(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> None:
return _BNFreeLinearViewCursor(cursor)
# -------------------------------------------------------
# _BNFreeLinearViewCursorPath
_BNFreeLinearViewCursorPath = core.BNFreeLinearViewCursorPath
_BNFreeLinearViewCursorPath.restype = None
_BNFreeLinearViewCursorPath.argtypes = [
ctypes.POINTER(BNLinearViewObjectIdentifier),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeLinearViewCursorPath(
objs: ctypes.POINTER(BNLinearViewObjectIdentifier),
count: int
) -> None:
return _BNFreeLinearViewCursorPath(objs, count)
# -------------------------------------------------------
# _BNFreeLinearViewCursorPathObjects
_BNFreeLinearViewCursorPathObjects = core.BNFreeLinearViewCursorPathObjects
_BNFreeLinearViewCursorPathObjects.restype = None
_BNFreeLinearViewCursorPathObjects.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNLinearViewObject)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeLinearViewCursorPathObjects(
objs: ctypes.POINTER(ctypes.POINTER(BNLinearViewObject)),
count: int
) -> None:
return _BNFreeLinearViewCursorPathObjects(objs, count)
# -------------------------------------------------------
# _BNFreeLinearViewObject
_BNFreeLinearViewObject = core.BNFreeLinearViewObject
_BNFreeLinearViewObject.restype = None
_BNFreeLinearViewObject.argtypes = [
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNFreeLinearViewObject(
obj: ctypes.POINTER(BNLinearViewObject)
) -> None:
return _BNFreeLinearViewObject(obj)
# -------------------------------------------------------
# _BNFreeLinearViewObjectIdentifier
_BNFreeLinearViewObjectIdentifier = core.BNFreeLinearViewObjectIdentifier
_BNFreeLinearViewObjectIdentifier.restype = None
_BNFreeLinearViewObjectIdentifier.argtypes = [
ctypes.POINTER(BNLinearViewObjectIdentifier),
]
# noinspection PyPep8Naming
def BNFreeLinearViewObjectIdentifier(
id: ctypes.POINTER(BNLinearViewObjectIdentifier)
) -> None:
return _BNFreeLinearViewObjectIdentifier(id)
# -------------------------------------------------------
# _BNFreeLogger
_BNFreeLogger = core.BNFreeLogger
_BNFreeLogger.restype = None
_BNFreeLogger.argtypes = [
ctypes.POINTER(BNLogger),
]
# noinspection PyPep8Naming
def BNFreeLogger(
logger: ctypes.POINTER(BNLogger)
) -> None:
return _BNFreeLogger(logger)
# -------------------------------------------------------
# _BNFreeLowLevelILFunction
_BNFreeLowLevelILFunction = core.BNFreeLowLevelILFunction
_BNFreeLowLevelILFunction.restype = None
_BNFreeLowLevelILFunction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNFreeLowLevelILFunction(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> None:
return _BNFreeLowLevelILFunction(func)
# -------------------------------------------------------
# _BNFreeMainThreadAction
_BNFreeMainThreadAction = core.BNFreeMainThreadAction
_BNFreeMainThreadAction.restype = None
_BNFreeMainThreadAction.argtypes = [
ctypes.POINTER(BNMainThreadAction),
]
# noinspection PyPep8Naming
def BNFreeMainThreadAction(
action: ctypes.POINTER(BNMainThreadAction)
) -> None:
return _BNFreeMainThreadAction(action)
# -------------------------------------------------------
# _BNFreeMediumLevelILFunction
_BNFreeMediumLevelILFunction = core.BNFreeMediumLevelILFunction
_BNFreeMediumLevelILFunction.restype = None
_BNFreeMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNFreeMediumLevelILFunction(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> None:
return _BNFreeMediumLevelILFunction(func)
# -------------------------------------------------------
# _BNFreeMemoryUsageInfo
_BNFreeMemoryUsageInfo = core.BNFreeMemoryUsageInfo
_BNFreeMemoryUsageInfo.restype = None
_BNFreeMemoryUsageInfo.argtypes = [
ctypes.POINTER(BNMemoryUsageInfo),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeMemoryUsageInfo(
info: ctypes.POINTER(BNMemoryUsageInfo),
count: int
) -> None:
return _BNFreeMemoryUsageInfo(info, count)
# -------------------------------------------------------
# _BNFreeMergedVariableList
_BNFreeMergedVariableList = core.BNFreeMergedVariableList
_BNFreeMergedVariableList.restype = None
_BNFreeMergedVariableList.argtypes = [
ctypes.POINTER(BNMergedVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeMergedVariableList(
vars: ctypes.POINTER(BNMergedVariable),
count: int
) -> None:
return _BNFreeMergedVariableList(vars, count)
# -------------------------------------------------------
# _BNFreeMetadata
_BNFreeMetadata = core.BNFreeMetadata
_BNFreeMetadata.restype = None
_BNFreeMetadata.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNFreeMetadata(
data: ctypes.POINTER(BNMetadata)
) -> None:
return _BNFreeMetadata(data)
# -------------------------------------------------------
# _BNFreeMetadataArray
_BNFreeMetadataArray = core.BNFreeMetadataArray
_BNFreeMetadataArray.restype = None
_BNFreeMetadataArray.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNMetadata)),
]
# noinspection PyPep8Naming
def BNFreeMetadataArray(
data: ctypes.POINTER(ctypes.POINTER(BNMetadata))
) -> None:
return _BNFreeMetadataArray(data)
# -------------------------------------------------------
# _BNFreeMetadataBooleanList
_BNFreeMetadataBooleanList = core.BNFreeMetadataBooleanList
_BNFreeMetadataBooleanList.restype = None
_BNFreeMetadataBooleanList.argtypes = [
ctypes.POINTER(ctypes.c_bool),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeMetadataBooleanList(
arg0: ctypes.POINTER(ctypes.c_bool),
arg1: int
) -> None:
return _BNFreeMetadataBooleanList(arg0, arg1)
# -------------------------------------------------------
# _BNFreeMetadataDoubleList
_BNFreeMetadataDoubleList = core.BNFreeMetadataDoubleList
_BNFreeMetadataDoubleList.restype = None
_BNFreeMetadataDoubleList.argtypes = [
ctypes.POINTER(ctypes.c_double),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeMetadataDoubleList(
arg0: ctypes.POINTER(ctypes.c_double),
arg1: int
) -> None:
return _BNFreeMetadataDoubleList(arg0, arg1)
# -------------------------------------------------------
# _BNFreeMetadataRaw
_BNFreeMetadataRaw = core.BNFreeMetadataRaw
_BNFreeMetadataRaw.restype = None
_BNFreeMetadataRaw.argtypes = [
ctypes.POINTER(ctypes.c_ubyte),
]
# noinspection PyPep8Naming
def BNFreeMetadataRaw(
data: ctypes.POINTER(ctypes.c_ubyte)
) -> None:
return _BNFreeMetadataRaw(data)
# -------------------------------------------------------
# _BNFreeMetadataSignedIntegerList
_BNFreeMetadataSignedIntegerList = core.BNFreeMetadataSignedIntegerList
_BNFreeMetadataSignedIntegerList.restype = None
_BNFreeMetadataSignedIntegerList.argtypes = [
ctypes.POINTER(ctypes.c_longlong),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeMetadataSignedIntegerList(
arg0: ctypes.POINTER(ctypes.c_longlong),
arg1: int
) -> None:
return _BNFreeMetadataSignedIntegerList(arg0, arg1)
# -------------------------------------------------------
# _BNFreeMetadataStringList
_BNFreeMetadataStringList = core.BNFreeMetadataStringList
_BNFreeMetadataStringList.restype = None
_BNFreeMetadataStringList.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeMetadataStringList(
arg0: ctypes.POINTER(ctypes.c_char_p),
arg1: int
) -> None:
return _BNFreeMetadataStringList(arg0, arg1)
# -------------------------------------------------------
# _BNFreeMetadataUnsignedIntegerList
_BNFreeMetadataUnsignedIntegerList = core.BNFreeMetadataUnsignedIntegerList
_BNFreeMetadataUnsignedIntegerList.restype = None
_BNFreeMetadataUnsignedIntegerList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeMetadataUnsignedIntegerList(
arg0: ctypes.POINTER(ctypes.c_ulonglong),
arg1: int
) -> None:
return _BNFreeMetadataUnsignedIntegerList(arg0, arg1)
# -------------------------------------------------------
# _BNFreeMetadataValueStore
_BNFreeMetadataValueStore = core.BNFreeMetadataValueStore
_BNFreeMetadataValueStore.restype = None
_BNFreeMetadataValueStore.argtypes = [
ctypes.POINTER(BNMetadataValueStore),
]
# noinspection PyPep8Naming
def BNFreeMetadataValueStore(
data: ctypes.POINTER(BNMetadataValueStore)
) -> None:
return _BNFreeMetadataValueStore(data)
# -------------------------------------------------------
# _BNFreeNameAndTypeList
_BNFreeNameAndTypeList = core.BNFreeNameAndTypeList
_BNFreeNameAndTypeList.restype = None
_BNFreeNameAndTypeList.argtypes = [
ctypes.POINTER(BNNameAndType),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeNameAndTypeList(
nt: ctypes.POINTER(BNNameAndType),
count: int
) -> None:
return _BNFreeNameAndTypeList(nt, count)
# -------------------------------------------------------
# _BNFreeNameSpace
_BNFreeNameSpace = core.BNFreeNameSpace
_BNFreeNameSpace.restype = None
_BNFreeNameSpace.argtypes = [
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNFreeNameSpace(
name: ctypes.POINTER(BNNameSpace)
) -> None:
return _BNFreeNameSpace(name)
# -------------------------------------------------------
# _BNFreeNameSpaceList
_BNFreeNameSpaceList = core.BNFreeNameSpaceList
_BNFreeNameSpaceList.restype = None
_BNFreeNameSpaceList.argtypes = [
ctypes.POINTER(BNNameSpace),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeNameSpaceList(
nameSpace: ctypes.POINTER(BNNameSpace),
count: int
) -> None:
return _BNFreeNameSpaceList(nameSpace, count)
# -------------------------------------------------------
# _BNFreeNamedTypeReference
_BNFreeNamedTypeReference = core.BNFreeNamedTypeReference
_BNFreeNamedTypeReference.restype = None
_BNFreeNamedTypeReference.argtypes = [
ctypes.POINTER(BNNamedTypeReference),
]
# noinspection PyPep8Naming
def BNFreeNamedTypeReference(
nt: ctypes.POINTER(BNNamedTypeReference)
) -> None:
return _BNFreeNamedTypeReference(nt)
# -------------------------------------------------------
# _BNFreeNamedTypeReferenceBuilder
_BNFreeNamedTypeReferenceBuilder = core.BNFreeNamedTypeReferenceBuilder
_BNFreeNamedTypeReferenceBuilder.restype = None
_BNFreeNamedTypeReferenceBuilder.argtypes = [
ctypes.POINTER(BNNamedTypeReferenceBuilder),
]
# noinspection PyPep8Naming
def BNFreeNamedTypeReferenceBuilder(
s: ctypes.POINTER(BNNamedTypeReferenceBuilder)
) -> None:
return _BNFreeNamedTypeReferenceBuilder(s)
# -------------------------------------------------------
# _BNFreeOutputTypeList
_BNFreeOutputTypeList = core.BNFreeOutputTypeList
_BNFreeOutputTypeList.restype = None
_BNFreeOutputTypeList.argtypes = [
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeOutputTypeList(
types: ctypes.POINTER(BNTypeWithConfidence),
count: int
) -> None:
return _BNFreeOutputTypeList(types, count)
# -------------------------------------------------------
# _BNFreeParameterVariables
_BNFreeParameterVariables = core.BNFreeParameterVariables
_BNFreeParameterVariables.restype = None
_BNFreeParameterVariables.argtypes = [
ctypes.POINTER(BNParameterVariablesWithConfidence),
]
# noinspection PyPep8Naming
def BNFreeParameterVariables(
vars: ctypes.POINTER(BNParameterVariablesWithConfidence)
) -> None:
return _BNFreeParameterVariables(vars)
# -------------------------------------------------------
# _BNFreeParseError
_BNFreeParseError = core.BNFreeParseError
_BNFreeParseError.restype = None
_BNFreeParseError.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNFreeParseError(
errorString: Optional[str]
) -> None:
return _BNFreeParseError(cstr(errorString))
# -------------------------------------------------------
# _BNFreePath
_BNFreePath = core.BNFreePath
_BNFreePath.restype = None
_BNFreePath.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNFreePath(
path: Optional[str]
) -> None:
return _BNFreePath(cstr(path))
# -------------------------------------------------------
# _BNFreePlatform
_BNFreePlatform = core.BNFreePlatform
_BNFreePlatform.restype = None
_BNFreePlatform.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNFreePlatform(
platform: ctypes.POINTER(BNPlatform)
) -> None:
return _BNFreePlatform(platform)
# -------------------------------------------------------
# _BNFreePlatformList
_BNFreePlatformList = core.BNFreePlatformList
_BNFreePlatformList.restype = None
_BNFreePlatformList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNPlatform)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreePlatformList(
platform: ctypes.POINTER(ctypes.POINTER(BNPlatform)),
count: int
) -> None:
return _BNFreePlatformList(platform, count)
# -------------------------------------------------------
# _BNFreePlatformOSList
_BNFreePlatformOSList = core.BNFreePlatformOSList
_BNFreePlatformOSList.restype = None
_BNFreePlatformOSList.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreePlatformOSList(
list: ctypes.POINTER(ctypes.c_char_p),
count: int
) -> None:
return _BNFreePlatformOSList(list, count)
# -------------------------------------------------------
# _BNFreePlugin
_BNFreePlugin = core.BNFreePlugin
_BNFreePlugin.restype = None
_BNFreePlugin.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNFreePlugin(
plugin: ctypes.POINTER(BNRepoPlugin)
) -> None:
return _BNFreePlugin(plugin)
# -------------------------------------------------------
# _BNFreePluginCommandList
_BNFreePluginCommandList = core.BNFreePluginCommandList
_BNFreePluginCommandList.restype = None
_BNFreePluginCommandList.argtypes = [
ctypes.POINTER(BNPluginCommand),
]
# noinspection PyPep8Naming
def BNFreePluginCommandList(
commands: ctypes.POINTER(BNPluginCommand)
) -> None:
return _BNFreePluginCommandList(commands)
# -------------------------------------------------------
# _BNFreePluginPlatforms
_BNFreePluginPlatforms = core.BNFreePluginPlatforms
_BNFreePluginPlatforms.restype = None
_BNFreePluginPlatforms.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreePluginPlatforms(
platforms: ctypes.POINTER(ctypes.c_char_p),
count: int
) -> None:
return _BNFreePluginPlatforms(platforms, count)
# -------------------------------------------------------
# _BNFreePluginTypes
_BNFreePluginTypes = core.BNFreePluginTypes
_BNFreePluginTypes.restype = None
_BNFreePluginTypes.argtypes = [
ctypes.POINTER(PluginTypeEnum),
]
# noinspection PyPep8Naming
def BNFreePluginTypes(
r: ctypes.POINTER(PluginTypeEnum)
) -> None:
return _BNFreePluginTypes(r)
# -------------------------------------------------------
# _BNFreePossibleValueSet
_BNFreePossibleValueSet = core.BNFreePossibleValueSet
_BNFreePossibleValueSet.restype = None
_BNFreePossibleValueSet.argtypes = [
ctypes.POINTER(BNPossibleValueSet),
]
# noinspection PyPep8Naming
def BNFreePossibleValueSet(
value: ctypes.POINTER(BNPossibleValueSet)
) -> None:
return _BNFreePossibleValueSet(value)
# -------------------------------------------------------
# _BNFreeProject
_BNFreeProject = core.BNFreeProject
_BNFreeProject.restype = None
_BNFreeProject.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNFreeProject(
project: ctypes.POINTER(BNProject)
) -> None:
return _BNFreeProject(project)
# -------------------------------------------------------
# _BNFreeProjectFile
_BNFreeProjectFile = core.BNFreeProjectFile
_BNFreeProjectFile.restype = None
_BNFreeProjectFile.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNFreeProjectFile(
file: ctypes.POINTER(BNProjectFile)
) -> None:
return _BNFreeProjectFile(file)
# -------------------------------------------------------
# _BNFreeProjectFileList
_BNFreeProjectFileList = core.BNFreeProjectFileList
_BNFreeProjectFileList.restype = None
_BNFreeProjectFileList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNProjectFile)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeProjectFileList(
files: ctypes.POINTER(ctypes.POINTER(BNProjectFile)),
count: int
) -> None:
return _BNFreeProjectFileList(files, count)
# -------------------------------------------------------
# _BNFreeProjectFolder
_BNFreeProjectFolder = core.BNFreeProjectFolder
_BNFreeProjectFolder.restype = None
_BNFreeProjectFolder.argtypes = [
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNFreeProjectFolder(
folder: ctypes.POINTER(BNProjectFolder)
) -> None:
return _BNFreeProjectFolder(folder)
# -------------------------------------------------------
# _BNFreeProjectFolderList
_BNFreeProjectFolderList = core.BNFreeProjectFolderList
_BNFreeProjectFolderList.restype = None
_BNFreeProjectFolderList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNProjectFolder)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeProjectFolderList(
folders: ctypes.POINTER(ctypes.POINTER(BNProjectFolder)),
count: int
) -> None:
return _BNFreeProjectFolderList(folders, count)
# -------------------------------------------------------
# _BNFreeProjectList
_BNFreeProjectList = core.BNFreeProjectList
_BNFreeProjectList.restype = None
_BNFreeProjectList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNProject)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeProjectList(
projects: ctypes.POINTER(ctypes.POINTER(BNProject)),
count: int
) -> None:
return _BNFreeProjectList(projects, count)
# -------------------------------------------------------
# _BNFreeQualifiedName
_BNFreeQualifiedName = core.BNFreeQualifiedName
_BNFreeQualifiedName.restype = None
_BNFreeQualifiedName.argtypes = [
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNFreeQualifiedName(
name: ctypes.POINTER(BNQualifiedName)
) -> None:
return _BNFreeQualifiedName(name)
# -------------------------------------------------------
# _BNFreeQualifiedNameAndType
_BNFreeQualifiedNameAndType = core.BNFreeQualifiedNameAndType
_BNFreeQualifiedNameAndType.restype = None
_BNFreeQualifiedNameAndType.argtypes = [
ctypes.POINTER(BNQualifiedNameAndType),
]
# noinspection PyPep8Naming
def BNFreeQualifiedNameAndType(
obj: ctypes.POINTER(BNQualifiedNameAndType)
) -> None:
return _BNFreeQualifiedNameAndType(obj)
# -------------------------------------------------------
# _BNFreeQualifiedNameAndTypeArray
_BNFreeQualifiedNameAndTypeArray = core.BNFreeQualifiedNameAndTypeArray
_BNFreeQualifiedNameAndTypeArray.restype = None
_BNFreeQualifiedNameAndTypeArray.argtypes = [
ctypes.POINTER(BNQualifiedNameAndType),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeQualifiedNameAndTypeArray(
obj: ctypes.POINTER(BNQualifiedNameAndType),
count: int
) -> None:
return _BNFreeQualifiedNameAndTypeArray(obj, count)
# -------------------------------------------------------
# _BNFreeQualifiedNameArray
_BNFreeQualifiedNameArray = core.BNFreeQualifiedNameArray
_BNFreeQualifiedNameArray.restype = None
_BNFreeQualifiedNameArray.argtypes = [
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeQualifiedNameArray(
names: ctypes.POINTER(BNQualifiedName),
count: int
) -> None:
return _BNFreeQualifiedNameArray(names, count)
# -------------------------------------------------------
# _BNFreeQualifiedNameTypeAndId
_BNFreeQualifiedNameTypeAndId = core.BNFreeQualifiedNameTypeAndId
_BNFreeQualifiedNameTypeAndId.restype = None
_BNFreeQualifiedNameTypeAndId.argtypes = [
ctypes.POINTER(BNQualifiedNameTypeAndId),
]
# noinspection PyPep8Naming
def BNFreeQualifiedNameTypeAndId(
obj: ctypes.POINTER(BNQualifiedNameTypeAndId)
) -> None:
return _BNFreeQualifiedNameTypeAndId(obj)
# -------------------------------------------------------
# _BNFreeRegisterList
_BNFreeRegisterList = core.BNFreeRegisterList
_BNFreeRegisterList.restype = None
_BNFreeRegisterList.argtypes = [
ctypes.POINTER(ctypes.c_uint),
]
# noinspection PyPep8Naming
def BNFreeRegisterList(
regs: ctypes.POINTER(ctypes.c_uint)
) -> None:
return _BNFreeRegisterList(regs)
# -------------------------------------------------------
# _BNFreeRegisterSet
_BNFreeRegisterSet = core.BNFreeRegisterSet
_BNFreeRegisterSet.restype = None
_BNFreeRegisterSet.argtypes = [
ctypes.POINTER(BNRegisterSetWithConfidence),
]
# noinspection PyPep8Naming
def BNFreeRegisterSet(
regs: ctypes.POINTER(BNRegisterSetWithConfidence)
) -> None:
return _BNFreeRegisterSet(regs)
# -------------------------------------------------------
# _BNFreeRegisterStackAdjustments
_BNFreeRegisterStackAdjustments = core.BNFreeRegisterStackAdjustments
_BNFreeRegisterStackAdjustments.restype = None
_BNFreeRegisterStackAdjustments.argtypes = [
ctypes.POINTER(BNRegisterStackAdjustment),
]
# noinspection PyPep8Naming
def BNFreeRegisterStackAdjustments(
adjustments: ctypes.POINTER(BNRegisterStackAdjustment)
) -> None:
return _BNFreeRegisterStackAdjustments(adjustments)
# -------------------------------------------------------
# _BNFreeRelocation
_BNFreeRelocation = core.BNFreeRelocation
_BNFreeRelocation.restype = None
_BNFreeRelocation.argtypes = [
ctypes.POINTER(BNRelocation),
]
# noinspection PyPep8Naming
def BNFreeRelocation(
reloc: ctypes.POINTER(BNRelocation)
) -> None:
return _BNFreeRelocation(reloc)
# -------------------------------------------------------
# _BNFreeRelocationHandler
_BNFreeRelocationHandler = core.BNFreeRelocationHandler
_BNFreeRelocationHandler.restype = None
_BNFreeRelocationHandler.argtypes = [
ctypes.POINTER(BNRelocationHandler),
]
# noinspection PyPep8Naming
def BNFreeRelocationHandler(
handler: ctypes.POINTER(BNRelocationHandler)
) -> None:
return _BNFreeRelocationHandler(handler)
# -------------------------------------------------------
# _BNFreeRelocationList
_BNFreeRelocationList = core.BNFreeRelocationList
_BNFreeRelocationList.restype = None
_BNFreeRelocationList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNRelocation)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeRelocationList(
relocations: ctypes.POINTER(ctypes.POINTER(BNRelocation)),
count: int
) -> None:
return _BNFreeRelocationList(relocations, count)
# -------------------------------------------------------
# _BNFreeRelocationRanges
_BNFreeRelocationRanges = core.BNFreeRelocationRanges
_BNFreeRelocationRanges.restype = None
_BNFreeRelocationRanges.argtypes = [
ctypes.POINTER(BNRange),
]
# noinspection PyPep8Naming
def BNFreeRelocationRanges(
ranges: ctypes.POINTER(BNRange)
) -> None:
return _BNFreeRelocationRanges(ranges)
# -------------------------------------------------------
# _BNFreeReportCollection
_BNFreeReportCollection = core.BNFreeReportCollection
_BNFreeReportCollection.restype = None
_BNFreeReportCollection.argtypes = [
ctypes.POINTER(BNReportCollection),
]
# noinspection PyPep8Naming
def BNFreeReportCollection(
reports: ctypes.POINTER(BNReportCollection)
) -> None:
return _BNFreeReportCollection(reports)
# -------------------------------------------------------
# _BNFreeRepository
_BNFreeRepository = core.BNFreeRepository
_BNFreeRepository.restype = None
_BNFreeRepository.argtypes = [
ctypes.POINTER(BNRepository),
]
# noinspection PyPep8Naming
def BNFreeRepository(
r: ctypes.POINTER(BNRepository)
) -> None:
return _BNFreeRepository(r)
# -------------------------------------------------------
# _BNFreeRepositoryManager
_BNFreeRepositoryManager = core.BNFreeRepositoryManager
_BNFreeRepositoryManager.restype = None
_BNFreeRepositoryManager.argtypes = [
ctypes.POINTER(BNRepositoryManager),
]
# noinspection PyPep8Naming
def BNFreeRepositoryManager(
r: ctypes.POINTER(BNRepositoryManager)
) -> None:
return _BNFreeRepositoryManager(r)
# -------------------------------------------------------
# _BNFreeRepositoryManagerRepositoriesList
_BNFreeRepositoryManagerRepositoriesList = core.BNFreeRepositoryManagerRepositoriesList
_BNFreeRepositoryManagerRepositoriesList.restype = None
_BNFreeRepositoryManagerRepositoriesList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNRepository)),
]
# noinspection PyPep8Naming
def BNFreeRepositoryManagerRepositoriesList(
r: ctypes.POINTER(ctypes.POINTER(BNRepository))
) -> None:
return _BNFreeRepositoryManagerRepositoriesList(r)
# -------------------------------------------------------
# _BNFreeRepositoryPluginList
_BNFreeRepositoryPluginList = core.BNFreeRepositoryPluginList
_BNFreeRepositoryPluginList.restype = None
_BNFreeRepositoryPluginList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNRepoPlugin)),
]
# noinspection PyPep8Naming
def BNFreeRepositoryPluginList(
r: ctypes.POINTER(ctypes.POINTER(BNRepoPlugin))
) -> None:
return _BNFreeRepositoryPluginList(r)
# -------------------------------------------------------
# _BNFreeSaveSettings
_BNFreeSaveSettings = core.BNFreeSaveSettings
_BNFreeSaveSettings.restype = None
_BNFreeSaveSettings.argtypes = [
ctypes.POINTER(BNSaveSettings),
]
# noinspection PyPep8Naming
def BNFreeSaveSettings(
settings: ctypes.POINTER(BNSaveSettings)
) -> None:
return _BNFreeSaveSettings(settings)
# -------------------------------------------------------
# _BNFreeScriptingInstance
_BNFreeScriptingInstance = core.BNFreeScriptingInstance
_BNFreeScriptingInstance.restype = None
_BNFreeScriptingInstance.argtypes = [
ctypes.POINTER(BNScriptingInstance),
]
# noinspection PyPep8Naming
def BNFreeScriptingInstance(
instance: ctypes.POINTER(BNScriptingInstance)
) -> None:
return _BNFreeScriptingInstance(instance)
# -------------------------------------------------------
# _BNFreeScriptingProviderList
_BNFreeScriptingProviderList = core.BNFreeScriptingProviderList
_BNFreeScriptingProviderList.restype = None
_BNFreeScriptingProviderList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNScriptingProvider)),
]
# noinspection PyPep8Naming
def BNFreeScriptingProviderList(
providers: ctypes.POINTER(ctypes.POINTER(BNScriptingProvider))
) -> None:
return _BNFreeScriptingProviderList(providers)
# -------------------------------------------------------
# _BNFreeSecretsProviderList
_BNFreeSecretsProviderList = core.BNFreeSecretsProviderList
_BNFreeSecretsProviderList.restype = None
_BNFreeSecretsProviderList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNSecretsProvider)),
]
# noinspection PyPep8Naming
def BNFreeSecretsProviderList(
providers: ctypes.POINTER(ctypes.POINTER(BNSecretsProvider))
) -> None:
return _BNFreeSecretsProviderList(providers)
# -------------------------------------------------------
# _BNFreeSection
_BNFreeSection = core.BNFreeSection
_BNFreeSection.restype = None
_BNFreeSection.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNFreeSection(
section: ctypes.POINTER(BNSection)
) -> None:
return _BNFreeSection(section)
# -------------------------------------------------------
# _BNFreeSectionList
_BNFreeSectionList = core.BNFreeSectionList
_BNFreeSectionList.restype = None
_BNFreeSectionList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNSection)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeSectionList(
sections: ctypes.POINTER(ctypes.POINTER(BNSection)),
count: int
) -> None:
return _BNFreeSectionList(sections, count)
# -------------------------------------------------------
# _BNFreeSegment
_BNFreeSegment = core.BNFreeSegment
_BNFreeSegment.restype = None
_BNFreeSegment.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNFreeSegment(
seg: ctypes.POINTER(BNSegment)
) -> None:
return _BNFreeSegment(seg)
# -------------------------------------------------------
# _BNFreeSegmentList
_BNFreeSegmentList = core.BNFreeSegmentList
_BNFreeSegmentList.restype = None
_BNFreeSegmentList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNSegment)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeSegmentList(
segments: ctypes.POINTER(ctypes.POINTER(BNSegment)),
count: int
) -> None:
return _BNFreeSegmentList(segments, count)
# -------------------------------------------------------
# _BNFreeSettings
_BNFreeSettings = core.BNFreeSettings
_BNFreeSettings.restype = None
_BNFreeSettings.argtypes = [
ctypes.POINTER(BNSettings),
]
# noinspection PyPep8Naming
def BNFreeSettings(
settings: ctypes.POINTER(BNSettings)
) -> None:
return _BNFreeSettings(settings)
# -------------------------------------------------------
# _BNFreeSnapshot
_BNFreeSnapshot = core.BNFreeSnapshot
_BNFreeSnapshot.restype = None
_BNFreeSnapshot.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNFreeSnapshot(
snapshot: ctypes.POINTER(BNSnapshot)
) -> None:
return _BNFreeSnapshot(snapshot)
# -------------------------------------------------------
# _BNFreeSnapshotList
_BNFreeSnapshotList = core.BNFreeSnapshotList
_BNFreeSnapshotList.restype = None
_BNFreeSnapshotList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNSnapshot)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeSnapshotList(
snapshots: ctypes.POINTER(ctypes.POINTER(BNSnapshot)),
count: int
) -> None:
return _BNFreeSnapshotList(snapshots, count)
# -------------------------------------------------------
# _BNFreeStackVariableReferenceList
_BNFreeStackVariableReferenceList = core.BNFreeStackVariableReferenceList
_BNFreeStackVariableReferenceList.restype = None
_BNFreeStackVariableReferenceList.argtypes = [
ctypes.POINTER(BNStackVariableReference),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeStackVariableReferenceList(
refs: ctypes.POINTER(BNStackVariableReference),
count: int
) -> None:
return _BNFreeStackVariableReferenceList(refs, count)
# -------------------------------------------------------
# _BNFreeString
_BNFreeString = core.BNFreeString
_BNFreeString.restype = None
_BNFreeString.argtypes = [
ctypes.POINTER(ctypes.c_byte),
]
# noinspection PyPep8Naming
def BNFreeString(
str: ctypes.c_char_p
) -> None:
return _BNFreeString(str)
# -------------------------------------------------------
# _BNFreeStringList
_BNFreeStringList = core.BNFreeStringList
_BNFreeStringList.restype = None
_BNFreeStringList.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeStringList(
strs: ctypes.POINTER(ctypes.c_char_p),
count: int
) -> None:
return _BNFreeStringList(strs, count)
# -------------------------------------------------------
# _BNFreeStringReferenceList
_BNFreeStringReferenceList = core.BNFreeStringReferenceList
_BNFreeStringReferenceList.restype = None
_BNFreeStringReferenceList.argtypes = [
ctypes.POINTER(BNStringReference),
]
# noinspection PyPep8Naming
def BNFreeStringReferenceList(
strings: ctypes.POINTER(BNStringReference)
) -> None:
return _BNFreeStringReferenceList(strings)
# -------------------------------------------------------
# _BNFreeStructure
_BNFreeStructure = core.BNFreeStructure
_BNFreeStructure.restype = None
_BNFreeStructure.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNFreeStructure(
s: ctypes.POINTER(BNStructure)
) -> None:
return _BNFreeStructure(s)
# -------------------------------------------------------
# _BNFreeStructureBuilder
_BNFreeStructureBuilder = core.BNFreeStructureBuilder
_BNFreeStructureBuilder.restype = None
_BNFreeStructureBuilder.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNFreeStructureBuilder(
s: ctypes.POINTER(BNStructureBuilder)
) -> None:
return _BNFreeStructureBuilder(s)
# -------------------------------------------------------
# _BNFreeStructureMember
_BNFreeStructureMember = core.BNFreeStructureMember
_BNFreeStructureMember.restype = None
_BNFreeStructureMember.argtypes = [
ctypes.POINTER(BNStructureMember),
]
# noinspection PyPep8Naming
def BNFreeStructureMember(
s: ctypes.POINTER(BNStructureMember)
) -> None:
return _BNFreeStructureMember(s)
# -------------------------------------------------------
# _BNFreeStructureMemberList
_BNFreeStructureMemberList = core.BNFreeStructureMemberList
_BNFreeStructureMemberList.restype = None
_BNFreeStructureMemberList.argtypes = [
ctypes.POINTER(BNStructureMember),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeStructureMemberList(
members: ctypes.POINTER(BNStructureMember),
count: int
) -> None:
return _BNFreeStructureMemberList(members, count)
# -------------------------------------------------------
# _BNFreeSymbol
_BNFreeSymbol = core.BNFreeSymbol
_BNFreeSymbol.restype = None
_BNFreeSymbol.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNFreeSymbol(
sym: ctypes.POINTER(BNSymbol)
) -> None:
return _BNFreeSymbol(sym)
# -------------------------------------------------------
# _BNFreeSymbolList
_BNFreeSymbolList = core.BNFreeSymbolList
_BNFreeSymbolList.restype = None
_BNFreeSymbolList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNSymbol)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeSymbolList(
syms: ctypes.POINTER(ctypes.POINTER(BNSymbol)),
count: int
) -> None:
return _BNFreeSymbolList(syms, count)
# -------------------------------------------------------
# _BNFreeSymbolRawBytes
_BNFreeSymbolRawBytes = core.BNFreeSymbolRawBytes
_BNFreeSymbolRawBytes.restype = None
_BNFreeSymbolRawBytes.argtypes = [
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNFreeSymbolRawBytes(
bytes: Optional[ctypes.c_void_p]
) -> None:
return _BNFreeSymbolRawBytes(bytes)
# -------------------------------------------------------
# _BNFreeSystemCallList
_BNFreeSystemCallList = core.BNFreeSystemCallList
_BNFreeSystemCallList.restype = None
_BNFreeSystemCallList.argtypes = [
ctypes.POINTER(BNSystemCallInfo),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeSystemCallList(
syscalls: ctypes.POINTER(BNSystemCallInfo),
count: int
) -> None:
return _BNFreeSystemCallList(syscalls, count)
# -------------------------------------------------------
# _BNFreeTag
_BNFreeTag = core.BNFreeTag
_BNFreeTag.restype = None
_BNFreeTag.argtypes = [
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNFreeTag(
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNFreeTag(tag)
# -------------------------------------------------------
# _BNFreeTagList
_BNFreeTagList = core.BNFreeTagList
_BNFreeTagList.restype = None
_BNFreeTagList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNTag)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTagList(
tags: ctypes.POINTER(ctypes.POINTER(BNTag)),
count: int
) -> None:
return _BNFreeTagList(tags, count)
# -------------------------------------------------------
# _BNFreeTagReferenceTypeCounts
_BNFreeTagReferenceTypeCounts = core.BNFreeTagReferenceTypeCounts
_BNFreeTagReferenceTypeCounts.restype = None
_BNFreeTagReferenceTypeCounts.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNTagType)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNFreeTagReferenceTypeCounts(
tagTypes: ctypes.POINTER(ctypes.POINTER(BNTagType)),
counts: ctypes.POINTER(ctypes.c_ulonglong)
) -> None:
return _BNFreeTagReferenceTypeCounts(tagTypes, counts)
# -------------------------------------------------------
# _BNFreeTagReferences
_BNFreeTagReferences = core.BNFreeTagReferences
_BNFreeTagReferences.restype = None
_BNFreeTagReferences.argtypes = [
ctypes.POINTER(BNTagReference),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTagReferences(
refs: ctypes.POINTER(BNTagReference),
count: int
) -> None:
return _BNFreeTagReferences(refs, count)
# -------------------------------------------------------
# _BNFreeTagType
_BNFreeTagType = core.BNFreeTagType
_BNFreeTagType.restype = None
_BNFreeTagType.argtypes = [
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNFreeTagType(
tagType: ctypes.POINTER(BNTagType)
) -> None:
return _BNFreeTagType(tagType)
# -------------------------------------------------------
# _BNFreeTagTypeList
_BNFreeTagTypeList = core.BNFreeTagTypeList
_BNFreeTagTypeList.restype = None
_BNFreeTagTypeList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNTagType)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTagTypeList(
tagTypes: ctypes.POINTER(ctypes.POINTER(BNTagType)),
count: int
) -> None:
return _BNFreeTagTypeList(tagTypes, count)
# -------------------------------------------------------
# _BNFreeTemporaryFile
_BNFreeTemporaryFile = core.BNFreeTemporaryFile
_BNFreeTemporaryFile.restype = None
_BNFreeTemporaryFile.argtypes = [
ctypes.POINTER(BNTemporaryFile),
]
# noinspection PyPep8Naming
def BNFreeTemporaryFile(
file: ctypes.POINTER(BNTemporaryFile)
) -> None:
return _BNFreeTemporaryFile(file)
# -------------------------------------------------------
# _BNFreeTransformParameterList
_BNFreeTransformParameterList = core.BNFreeTransformParameterList
_BNFreeTransformParameterList.restype = None
_BNFreeTransformParameterList.argtypes = [
ctypes.POINTER(BNTransformParameterInfo),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTransformParameterList(
params: ctypes.POINTER(BNTransformParameterInfo),
count: int
) -> None:
return _BNFreeTransformParameterList(params, count)
# -------------------------------------------------------
# _BNFreeTransformTypeList
_BNFreeTransformTypeList = core.BNFreeTransformTypeList
_BNFreeTransformTypeList.restype = None
_BNFreeTransformTypeList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNTransform)),
]
# noinspection PyPep8Naming
def BNFreeTransformTypeList(
xforms: ctypes.POINTER(ctypes.POINTER(BNTransform))
) -> None:
return _BNFreeTransformTypeList(xforms)
# -------------------------------------------------------
# _BNFreeType
_BNFreeType = core.BNFreeType
_BNFreeType.restype = None
_BNFreeType.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNFreeType(
type: ctypes.POINTER(BNType)
) -> None:
return _BNFreeType(type)
# -------------------------------------------------------
# _BNFreeTypeAndNameList
_BNFreeTypeAndNameList = core.BNFreeTypeAndNameList
_BNFreeTypeAndNameList.restype = None
_BNFreeTypeAndNameList.argtypes = [
ctypes.POINTER(BNQualifiedNameAndType),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeAndNameList(
types: ctypes.POINTER(BNQualifiedNameAndType),
count: int
) -> None:
return _BNFreeTypeAndNameList(types, count)
# -------------------------------------------------------
# _BNFreeTypeArchiveList
_BNFreeTypeArchiveList = core.BNFreeTypeArchiveList
_BNFreeTypeArchiveList.restype = None
_BNFreeTypeArchiveList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNTypeArchive)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeArchiveList(
archives: ctypes.POINTER(ctypes.POINTER(BNTypeArchive)),
count: int
) -> None:
return _BNFreeTypeArchiveList(archives, count)
# -------------------------------------------------------
# _BNFreeTypeArchiveReference
_BNFreeTypeArchiveReference = core.BNFreeTypeArchiveReference
_BNFreeTypeArchiveReference.restype = None
_BNFreeTypeArchiveReference.argtypes = [
ctypes.POINTER(BNTypeArchive),
]
# noinspection PyPep8Naming
def BNFreeTypeArchiveReference(
archive: ctypes.POINTER(BNTypeArchive)
) -> None:
return _BNFreeTypeArchiveReference(archive)
# -------------------------------------------------------
# _BNFreeTypeBuilder
_BNFreeTypeBuilder = core.BNFreeTypeBuilder
_BNFreeTypeBuilder.restype = None
_BNFreeTypeBuilder.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNFreeTypeBuilder(
type: ctypes.POINTER(BNTypeBuilder)
) -> None:
return _BNFreeTypeBuilder(type)
# -------------------------------------------------------
# _BNFreeTypeContainer
_BNFreeTypeContainer = core.BNFreeTypeContainer
_BNFreeTypeContainer.restype = None
_BNFreeTypeContainer.argtypes = [
ctypes.POINTER(BNTypeContainer),
]
# noinspection PyPep8Naming
def BNFreeTypeContainer(
container: ctypes.POINTER(BNTypeContainer)
) -> None:
return _BNFreeTypeContainer(container)
# -------------------------------------------------------
# _BNFreeTypeDefinitionLineList
_BNFreeTypeDefinitionLineList = core.BNFreeTypeDefinitionLineList
_BNFreeTypeDefinitionLineList.restype = None
_BNFreeTypeDefinitionLineList.argtypes = [
ctypes.POINTER(BNTypeDefinitionLine),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeDefinitionLineList(
list: ctypes.POINTER(BNTypeDefinitionLine),
count: int
) -> None:
return _BNFreeTypeDefinitionLineList(list, count)
# -------------------------------------------------------
# _BNFreeTypeFieldReferenceSizeInfo
_BNFreeTypeFieldReferenceSizeInfo = core.BNFreeTypeFieldReferenceSizeInfo
_BNFreeTypeFieldReferenceSizeInfo.restype = None
_BNFreeTypeFieldReferenceSizeInfo.argtypes = [
ctypes.POINTER(BNTypeFieldReferenceSizeInfo),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeFieldReferenceSizeInfo(
refs: ctypes.POINTER(BNTypeFieldReferenceSizeInfo),
count: int
) -> None:
return _BNFreeTypeFieldReferenceSizeInfo(refs, count)
# -------------------------------------------------------
# _BNFreeTypeFieldReferenceSizes
_BNFreeTypeFieldReferenceSizes = core.BNFreeTypeFieldReferenceSizes
_BNFreeTypeFieldReferenceSizes.restype = None
_BNFreeTypeFieldReferenceSizes.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeFieldReferenceSizes(
refs: ctypes.POINTER(ctypes.c_ulonglong),
count: int
) -> None:
return _BNFreeTypeFieldReferenceSizes(refs, count)
# -------------------------------------------------------
# _BNFreeTypeFieldReferenceTypeInfo
_BNFreeTypeFieldReferenceTypeInfo = core.BNFreeTypeFieldReferenceTypeInfo
_BNFreeTypeFieldReferenceTypeInfo.restype = None
_BNFreeTypeFieldReferenceTypeInfo.argtypes = [
ctypes.POINTER(BNTypeFieldReferenceTypeInfo),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeFieldReferenceTypeInfo(
refs: ctypes.POINTER(BNTypeFieldReferenceTypeInfo),
count: int
) -> None:
return _BNFreeTypeFieldReferenceTypeInfo(refs, count)
# -------------------------------------------------------
# _BNFreeTypeFieldReferenceTypes
_BNFreeTypeFieldReferenceTypes = core.BNFreeTypeFieldReferenceTypes
_BNFreeTypeFieldReferenceTypes.restype = None
_BNFreeTypeFieldReferenceTypes.argtypes = [
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeFieldReferenceTypes(
refs: ctypes.POINTER(BNTypeWithConfidence),
count: int
) -> None:
return _BNFreeTypeFieldReferenceTypes(refs, count)
# -------------------------------------------------------
# _BNFreeTypeFieldReferences
_BNFreeTypeFieldReferences = core.BNFreeTypeFieldReferences
_BNFreeTypeFieldReferences.restype = None
_BNFreeTypeFieldReferences.argtypes = [
ctypes.POINTER(BNTypeFieldReference),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeFieldReferences(
refs: ctypes.POINTER(BNTypeFieldReference),
count: int
) -> None:
return _BNFreeTypeFieldReferences(refs, count)
# -------------------------------------------------------
# _BNFreeTypeIdList
_BNFreeTypeIdList = core.BNFreeTypeIdList
_BNFreeTypeIdList.restype = None
_BNFreeTypeIdList.argtypes = [
ctypes.POINTER(BNQualifiedNameTypeAndId),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeIdList(
types: ctypes.POINTER(BNQualifiedNameTypeAndId),
count: int
) -> None:
return _BNFreeTypeIdList(types, count)
# -------------------------------------------------------
# _BNFreeTypeLibrary
_BNFreeTypeLibrary = core.BNFreeTypeLibrary
_BNFreeTypeLibrary.restype = None
_BNFreeTypeLibrary.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNFreeTypeLibrary(
lib: ctypes.POINTER(BNTypeLibrary)
) -> None:
return _BNFreeTypeLibrary(lib)
# -------------------------------------------------------
# _BNFreeTypeLibraryList
_BNFreeTypeLibraryList = core.BNFreeTypeLibraryList
_BNFreeTypeLibraryList.restype = None
_BNFreeTypeLibraryList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeLibraryList(
lib: ctypes.POINTER(ctypes.POINTER(BNTypeLibrary)),
count: int
) -> None:
return _BNFreeTypeLibraryList(lib, count)
# -------------------------------------------------------
# _BNFreeTypeList
_BNFreeTypeList = core.BNFreeTypeList
_BNFreeTypeList.restype = None
_BNFreeTypeList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeList(
types: ctypes.POINTER(ctypes.POINTER(BNType)),
count: int
) -> None:
return _BNFreeTypeList(types, count)
# -------------------------------------------------------
# _BNFreeTypeNameList
_BNFreeTypeNameList = core.BNFreeTypeNameList
_BNFreeTypeNameList.restype = None
_BNFreeTypeNameList.argtypes = [
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeNameList(
names: ctypes.POINTER(BNQualifiedName),
count: int
) -> None:
return _BNFreeTypeNameList(names, count)
# -------------------------------------------------------
# _BNFreeTypeParameterList
_BNFreeTypeParameterList = core.BNFreeTypeParameterList
_BNFreeTypeParameterList.restype = None
_BNFreeTypeParameterList.argtypes = [
ctypes.POINTER(BNFunctionParameter),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeParameterList(
types: ctypes.POINTER(BNFunctionParameter),
count: int
) -> None:
return _BNFreeTypeParameterList(types, count)
# -------------------------------------------------------
# _BNFreeTypeParserErrors
_BNFreeTypeParserErrors = core.BNFreeTypeParserErrors
_BNFreeTypeParserErrors.restype = None
_BNFreeTypeParserErrors.argtypes = [
ctypes.POINTER(BNTypeParserError),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeParserErrors(
errors: ctypes.POINTER(BNTypeParserError),
count: int
) -> None:
return _BNFreeTypeParserErrors(errors, count)
# -------------------------------------------------------
# _BNFreeTypeParserList
_BNFreeTypeParserList = core.BNFreeTypeParserList
_BNFreeTypeParserList.restype = None
_BNFreeTypeParserList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNTypeParser)),
]
# noinspection PyPep8Naming
def BNFreeTypeParserList(
parsers: ctypes.POINTER(ctypes.POINTER(BNTypeParser))
) -> None:
return _BNFreeTypeParserList(parsers)
# -------------------------------------------------------
# _BNFreeTypeParserResult
_BNFreeTypeParserResult = core.BNFreeTypeParserResult
_BNFreeTypeParserResult.restype = None
_BNFreeTypeParserResult.argtypes = [
ctypes.POINTER(BNTypeParserResult),
]
# noinspection PyPep8Naming
def BNFreeTypeParserResult(
result: ctypes.POINTER(BNTypeParserResult)
) -> None:
return _BNFreeTypeParserResult(result)
# -------------------------------------------------------
# _BNFreeTypePrinterList
_BNFreeTypePrinterList = core.BNFreeTypePrinterList
_BNFreeTypePrinterList.restype = None
_BNFreeTypePrinterList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNTypePrinter)),
]
# noinspection PyPep8Naming
def BNFreeTypePrinterList(
printers: ctypes.POINTER(ctypes.POINTER(BNTypePrinter))
) -> None:
return _BNFreeTypePrinterList(printers)
# -------------------------------------------------------
# _BNFreeTypeReferences
_BNFreeTypeReferences = core.BNFreeTypeReferences
_BNFreeTypeReferences.restype = None
_BNFreeTypeReferences.argtypes = [
ctypes.POINTER(BNTypeReferenceSource),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeTypeReferences(
refs: ctypes.POINTER(BNTypeReferenceSource),
count: int
) -> None:
return _BNFreeTypeReferences(refs, count)
# -------------------------------------------------------
# _BNFreeUndoEntries
_BNFreeUndoEntries = core.BNFreeUndoEntries
_BNFreeUndoEntries.restype = None
_BNFreeUndoEntries.argtypes = [
ctypes.POINTER(BNUndoEntry),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeUndoEntries(
entries: ctypes.POINTER(BNUndoEntry),
count: int
) -> None:
return _BNFreeUndoEntries(entries, count)
# -------------------------------------------------------
# _BNFreeUpdateChannelList
_BNFreeUpdateChannelList = core.BNFreeUpdateChannelList
_BNFreeUpdateChannelList.restype = None
_BNFreeUpdateChannelList.argtypes = [
ctypes.POINTER(BNUpdateChannel),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeUpdateChannelList(
list: ctypes.POINTER(BNUpdateChannel),
count: int
) -> None:
return _BNFreeUpdateChannelList(list, count)
# -------------------------------------------------------
# _BNFreeUpdateChannelVersionList
_BNFreeUpdateChannelVersionList = core.BNFreeUpdateChannelVersionList
_BNFreeUpdateChannelVersionList.restype = None
_BNFreeUpdateChannelVersionList.argtypes = [
ctypes.POINTER(BNUpdateVersion),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeUpdateChannelVersionList(
list: ctypes.POINTER(BNUpdateVersion),
count: int
) -> None:
return _BNFreeUpdateChannelVersionList(list, count)
# -------------------------------------------------------
# _BNFreeUser
_BNFreeUser = core.BNFreeUser
_BNFreeUser.restype = None
_BNFreeUser.argtypes = [
ctypes.POINTER(BNUser),
]
# noinspection PyPep8Naming
def BNFreeUser(
user: ctypes.POINTER(BNUser)
) -> None:
return _BNFreeUser(user)
# -------------------------------------------------------
# _BNFreeUserList
_BNFreeUserList = core.BNFreeUserList
_BNFreeUserList.restype = None
_BNFreeUserList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNUser)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeUserList(
users: ctypes.POINTER(ctypes.POINTER(BNUser)),
count: int
) -> None:
return _BNFreeUserList(users, count)
# -------------------------------------------------------
# _BNFreeUserVariableValues
_BNFreeUserVariableValues = core.BNFreeUserVariableValues
_BNFreeUserVariableValues.restype = None
_BNFreeUserVariableValues.argtypes = [
ctypes.POINTER(BNUserVariableValue),
]
# noinspection PyPep8Naming
def BNFreeUserVariableValues(
result: ctypes.POINTER(BNUserVariableValue)
) -> None:
return _BNFreeUserVariableValues(result)
# -------------------------------------------------------
# _BNFreeVariableList
_BNFreeVariableList = core.BNFreeVariableList
_BNFreeVariableList.restype = None
_BNFreeVariableList.argtypes = [
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNFreeVariableList(
vars: ctypes.POINTER(BNVariable)
) -> None:
return _BNFreeVariableList(vars)
# -------------------------------------------------------
# _BNFreeVariableNameAndType
_BNFreeVariableNameAndType = core.BNFreeVariableNameAndType
_BNFreeVariableNameAndType.restype = None
_BNFreeVariableNameAndType.argtypes = [
ctypes.POINTER(BNVariableNameAndType),
]
# noinspection PyPep8Naming
def BNFreeVariableNameAndType(
var: ctypes.POINTER(BNVariableNameAndType)
) -> None:
return _BNFreeVariableNameAndType(var)
# -------------------------------------------------------
# _BNFreeVariableNameAndTypeList
_BNFreeVariableNameAndTypeList = core.BNFreeVariableNameAndTypeList
_BNFreeVariableNameAndTypeList.restype = None
_BNFreeVariableNameAndTypeList.argtypes = [
ctypes.POINTER(BNVariableNameAndType),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeVariableNameAndTypeList(
vars: ctypes.POINTER(BNVariableNameAndType),
count: int
) -> None:
return _BNFreeVariableNameAndTypeList(vars, count)
# -------------------------------------------------------
# _BNFreeVariableReferenceSourceList
_BNFreeVariableReferenceSourceList = core.BNFreeVariableReferenceSourceList
_BNFreeVariableReferenceSourceList.restype = None
_BNFreeVariableReferenceSourceList.argtypes = [
ctypes.POINTER(BNVariableReferenceSource),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeVariableReferenceSourceList(
vars: ctypes.POINTER(BNVariableReferenceSource),
count: int
) -> None:
return _BNFreeVariableReferenceSourceList(vars, count)
# -------------------------------------------------------
# _BNFreeWebsocketClient
_BNFreeWebsocketClient = core.BNFreeWebsocketClient
_BNFreeWebsocketClient.restype = None
_BNFreeWebsocketClient.argtypes = [
ctypes.POINTER(BNWebsocketClient),
]
# noinspection PyPep8Naming
def BNFreeWebsocketClient(
client: ctypes.POINTER(BNWebsocketClient)
) -> None:
return _BNFreeWebsocketClient(client)
# -------------------------------------------------------
# _BNFreeWebsocketProviderList
_BNFreeWebsocketProviderList = core.BNFreeWebsocketProviderList
_BNFreeWebsocketProviderList.restype = None
_BNFreeWebsocketProviderList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNWebsocketProvider)),
]
# noinspection PyPep8Naming
def BNFreeWebsocketProviderList(
providers: ctypes.POINTER(ctypes.POINTER(BNWebsocketProvider))
) -> None:
return _BNFreeWebsocketProviderList(providers)
# -------------------------------------------------------
# _BNFreeWorkflow
_BNFreeWorkflow = core.BNFreeWorkflow
_BNFreeWorkflow.restype = None
_BNFreeWorkflow.argtypes = [
ctypes.POINTER(BNWorkflow),
]
# noinspection PyPep8Naming
def BNFreeWorkflow(
workflow: ctypes.POINTER(BNWorkflow)
) -> None:
return _BNFreeWorkflow(workflow)
# -------------------------------------------------------
# _BNFreeWorkflowList
_BNFreeWorkflowList = core.BNFreeWorkflowList
_BNFreeWorkflowList.restype = None
_BNFreeWorkflowList.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNWorkflow)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFreeWorkflowList(
workflows: ctypes.POINTER(ctypes.POINTER(BNWorkflow)),
count: int
) -> None:
return _BNFreeWorkflowList(workflows, count)
# -------------------------------------------------------
# _BNFromVariableIdentifier
_BNFromVariableIdentifier = core.BNFromVariableIdentifier
_BNFromVariableIdentifier.restype = BNVariable
_BNFromVariableIdentifier.argtypes = [
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNFromVariableIdentifier(
id: int
) -> BNVariable:
return _BNFromVariableIdentifier(id)
# -------------------------------------------------------
# _BNFunctionHasExplicitlyDefinedType
_BNFunctionHasExplicitlyDefinedType = core.BNFunctionHasExplicitlyDefinedType
_BNFunctionHasExplicitlyDefinedType.restype = ctypes.c_bool
_BNFunctionHasExplicitlyDefinedType.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNFunctionHasExplicitlyDefinedType(
func: ctypes.POINTER(BNFunction)
) -> bool:
return _BNFunctionHasExplicitlyDefinedType(func)
# -------------------------------------------------------
# _BNFunctionHasUserAnnotations
_BNFunctionHasUserAnnotations = core.BNFunctionHasUserAnnotations
_BNFunctionHasUserAnnotations.restype = ctypes.c_bool
_BNFunctionHasUserAnnotations.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNFunctionHasUserAnnotations(
func: ctypes.POINTER(BNFunction)
) -> bool:
return _BNFunctionHasUserAnnotations(func)
# -------------------------------------------------------
# _BNFunctionHasUserType
_BNFunctionHasUserType = core.BNFunctionHasUserType
_BNFunctionHasUserType.restype = ctypes.c_bool
_BNFunctionHasUserType.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNFunctionHasUserType(
func: ctypes.POINTER(BNFunction)
) -> bool:
return _BNFunctionHasUserType(func)
# -------------------------------------------------------
# _BNFunctionHasVariableArguments
_BNFunctionHasVariableArguments = core.BNFunctionHasVariableArguments
_BNFunctionHasVariableArguments.restype = BNBoolWithConfidence
_BNFunctionHasVariableArguments.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNFunctionHasVariableArguments(
func: ctypes.POINTER(BNFunction)
) -> BNBoolWithConfidence:
return _BNFunctionHasVariableArguments(func)
# -------------------------------------------------------
# _BNFunctionTypeBuilderCanReturn
_BNFunctionTypeBuilderCanReturn = core.BNFunctionTypeBuilderCanReturn
_BNFunctionTypeBuilderCanReturn.restype = BNBoolWithConfidence
_BNFunctionTypeBuilderCanReturn.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNFunctionTypeBuilderCanReturn(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNBoolWithConfidence:
return _BNFunctionTypeBuilderCanReturn(type)
# -------------------------------------------------------
# _BNFunctionTypeCanReturn
_BNFunctionTypeCanReturn = core.BNFunctionTypeCanReturn
_BNFunctionTypeCanReturn.restype = BNBoolWithConfidence
_BNFunctionTypeCanReturn.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNFunctionTypeCanReturn(
type: ctypes.POINTER(BNType)
) -> BNBoolWithConfidence:
return _BNFunctionTypeCanReturn(type)
# -------------------------------------------------------
# _BNGenerateAutoDebugTypeId
_BNGenerateAutoDebugTypeId = core.BNGenerateAutoDebugTypeId
_BNGenerateAutoDebugTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGenerateAutoDebugTypeId.argtypes = [
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGenerateAutoDebugTypeId(
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[Optional[str]]:
result = _BNGenerateAutoDebugTypeId(name)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGenerateAutoDemangledTypeId
_BNGenerateAutoDemangledTypeId = core.BNGenerateAutoDemangledTypeId
_BNGenerateAutoDemangledTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGenerateAutoDemangledTypeId.argtypes = [
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGenerateAutoDemangledTypeId(
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[Optional[str]]:
result = _BNGenerateAutoDemangledTypeId(name)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGenerateAutoPlatformTypeId
_BNGenerateAutoPlatformTypeId = core.BNGenerateAutoPlatformTypeId
_BNGenerateAutoPlatformTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGenerateAutoPlatformTypeId.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGenerateAutoPlatformTypeId(
platform: ctypes.POINTER(BNPlatform),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[Optional[str]]:
result = _BNGenerateAutoPlatformTypeId(platform, name)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGenerateAutoTypeId
_BNGenerateAutoTypeId = core.BNGenerateAutoTypeId
_BNGenerateAutoTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGenerateAutoTypeId.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGenerateAutoTypeId(
source: Optional[str],
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[Optional[str]]:
result = _BNGenerateAutoTypeId(cstr(source), name)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGenerateHighLevelILSSAForm
_BNGenerateHighLevelILSSAForm = core.BNGenerateHighLevelILSSAForm
_BNGenerateHighLevelILSSAForm.restype = None
_BNGenerateHighLevelILSSAForm.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGenerateHighLevelILSSAForm(
func: ctypes.POINTER(BNHighLevelILFunction),
aliases: ctypes.POINTER(BNVariable),
aliasCount: int
) -> None:
return _BNGenerateHighLevelILSSAForm(func, aliases, aliasCount)
# -------------------------------------------------------
# _BNGenerateLowLevelILSSAForm
_BNGenerateLowLevelILSSAForm = core.BNGenerateLowLevelILSSAForm
_BNGenerateLowLevelILSSAForm.restype = None
_BNGenerateLowLevelILSSAForm.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGenerateLowLevelILSSAForm(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> None:
return _BNGenerateLowLevelILSSAForm(func)
# -------------------------------------------------------
# _BNGenerateMediumLevelILSSAForm
_BNGenerateMediumLevelILSSAForm = core.BNGenerateMediumLevelILSSAForm
_BNGenerateMediumLevelILSSAForm.restype = None
_BNGenerateMediumLevelILSSAForm.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_bool,
ctypes.c_bool,
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGenerateMediumLevelILSSAForm(
func: ctypes.POINTER(BNMediumLevelILFunction),
analyzeConditionals: bool,
handleAliases: bool,
knownNotAliases: ctypes.POINTER(BNVariable),
knownNotAliasCount: int,
knownAliases: ctypes.POINTER(BNVariable),
knownAliasCount: int
) -> None:
return _BNGenerateMediumLevelILSSAForm(func, analyzeConditionals, handleAliases, knownNotAliases, knownNotAliasCount, knownAliases, knownAliasCount)
# -------------------------------------------------------
# _BNGetActiveUpdateChannel
_BNGetActiveUpdateChannel = core.BNGetActiveUpdateChannel
_BNGetActiveUpdateChannel.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetActiveUpdateChannel.argtypes = [
]
# noinspection PyPep8Naming
def BNGetActiveUpdateChannel(
) -> Optional[Optional[str]]:
result = _BNGetActiveUpdateChannel()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetAddressForDataOffset
_BNGetAddressForDataOffset = core.BNGetAddressForDataOffset
_BNGetAddressForDataOffset.restype = ctypes.c_bool
_BNGetAddressForDataOffset.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAddressForDataOffset(
view: ctypes.POINTER(BNBinaryView),
offset: int,
addr: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetAddressForDataOffset(view, offset, addr)
# -------------------------------------------------------
# _BNGetAddressInput
_BNGetAddressInput = core.BNGetAddressInput
_BNGetAddressInput.restype = ctypes.c_bool
_BNGetAddressInput.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetAddressInput(
result: ctypes.POINTER(ctypes.c_ulonglong),
prompt: Optional[str],
title: Optional[str],
view: ctypes.POINTER(BNBinaryView),
currentAddr: int
) -> bool:
return _BNGetAddressInput(result, cstr(prompt), cstr(title), view, currentAddr)
# -------------------------------------------------------
# _BNGetAddressRenderedWidth
_BNGetAddressRenderedWidth = core.BNGetAddressRenderedWidth
_BNGetAddressRenderedWidth.restype = ctypes.c_uint
_BNGetAddressRenderedWidth.argtypes = [
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetAddressRenderedWidth(
addr: int
) -> int:
return _BNGetAddressRenderedWidth(addr)
# -------------------------------------------------------
# _BNGetAddressTagReferences
_BNGetAddressTagReferences = core.BNGetAddressTagReferences
_BNGetAddressTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAddressTagReferences.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAddressTagReferences(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAddressTagReferences(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAddressTags
_BNGetAddressTags = core.BNGetAddressTags
_BNGetAddressTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAddressTags.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAddressTags(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetAddressTags(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAddressTagsInRange
_BNGetAddressTagsInRange = core.BNGetAddressTagsInRange
_BNGetAddressTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetAddressTagsInRange.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAddressTagsInRange(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
start: int,
end: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAddressTagsInRange(func, arch, start, end, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAddressTagsOfType
_BNGetAddressTagsOfType = core.BNGetAddressTagsOfType
_BNGetAddressTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAddressTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAddressTagsOfType(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetAddressTagsOfType(func, arch, addr, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllAddressTagReferences
_BNGetAllAddressTagReferences = core.BNGetAllAddressTagReferences
_BNGetAllAddressTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAllAddressTagReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllAddressTagReferences(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAllAddressTagReferences(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllArchitectureFlagWriteTypes
_BNGetAllArchitectureFlagWriteTypes = core.BNGetAllArchitectureFlagWriteTypes
_BNGetAllArchitectureFlagWriteTypes.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureFlagWriteTypes.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllArchitectureFlagWriteTypes(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetAllArchitectureFlagWriteTypes(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllArchitectureFlags
_BNGetAllArchitectureFlags = core.BNGetAllArchitectureFlags
_BNGetAllArchitectureFlags.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureFlags.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllArchitectureFlags(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetAllArchitectureFlags(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllArchitectureIntrinsics
_BNGetAllArchitectureIntrinsics = core.BNGetAllArchitectureIntrinsics
_BNGetAllArchitectureIntrinsics.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureIntrinsics.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllArchitectureIntrinsics(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetAllArchitectureIntrinsics(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllArchitectureRegisterStacks
_BNGetAllArchitectureRegisterStacks = core.BNGetAllArchitectureRegisterStacks
_BNGetAllArchitectureRegisterStacks.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureRegisterStacks.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllArchitectureRegisterStacks(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetAllArchitectureRegisterStacks(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllArchitectureRegisters
_BNGetAllArchitectureRegisters = core.BNGetAllArchitectureRegisters
_BNGetAllArchitectureRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureRegisters.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllArchitectureRegisters(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetAllArchitectureRegisters(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllArchitectureSemanticFlagClasses
_BNGetAllArchitectureSemanticFlagClasses = core.BNGetAllArchitectureSemanticFlagClasses
_BNGetAllArchitectureSemanticFlagClasses.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureSemanticFlagClasses.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllArchitectureSemanticFlagClasses(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetAllArchitectureSemanticFlagClasses(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllArchitectureSemanticFlagGroups
_BNGetAllArchitectureSemanticFlagGroups = core.BNGetAllArchitectureSemanticFlagGroups
_BNGetAllArchitectureSemanticFlagGroups.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetAllArchitectureSemanticFlagGroups.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllArchitectureSemanticFlagGroups(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetAllArchitectureSemanticFlagGroups(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllFieldsReferenced
_BNGetAllFieldsReferenced = core.BNGetAllFieldsReferenced
_BNGetAllFieldsReferenced.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetAllFieldsReferenced.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllFieldsReferenced(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetAllFieldsReferenced(view, type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllFunctionTagReferences
_BNGetAllFunctionTagReferences = core.BNGetAllFunctionTagReferences
_BNGetAllFunctionTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAllFunctionTagReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllFunctionTagReferences(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAllFunctionTagReferences(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllMediumLevelILBranchDependence
_BNGetAllMediumLevelILBranchDependence = core.BNGetAllMediumLevelILBranchDependence
_BNGetAllMediumLevelILBranchDependence.restype = ctypes.POINTER(BNILBranchInstructionAndDependence)
_BNGetAllMediumLevelILBranchDependence.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllMediumLevelILBranchDependence(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNILBranchInstructionAndDependence)]:
result = _BNGetAllMediumLevelILBranchDependence(func, instr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllPluginCommands
_BNGetAllPluginCommands = core.BNGetAllPluginCommands
_BNGetAllPluginCommands.restype = ctypes.POINTER(BNPluginCommand)
_BNGetAllPluginCommands.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllPluginCommands(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetAllPluginCommands(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllSizesReferenced
_BNGetAllSizesReferenced = core.BNGetAllSizesReferenced
_BNGetAllSizesReferenced.restype = ctypes.POINTER(BNTypeFieldReferenceSizeInfo)
_BNGetAllSizesReferenced.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllSizesReferenced(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeFieldReferenceSizeInfo)]:
result = _BNGetAllSizesReferenced(view, type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllTagReferenceTypeCounts
_BNGetAllTagReferenceTypeCounts = core.BNGetAllTagReferenceTypeCounts
_BNGetAllTagReferenceTypeCounts.restype = None
_BNGetAllTagReferenceTypeCounts.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(BNTagType))),
ctypes.POINTER(ctypes.POINTER(ctypes.c_ulonglong)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllTagReferenceTypeCounts(
view: ctypes.POINTER(BNBinaryView),
tagTypes: ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(BNTagType))),
counts: ctypes.POINTER(ctypes.POINTER(ctypes.c_ulonglong)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> None:
return _BNGetAllTagReferenceTypeCounts(view, tagTypes, counts, count)
# -------------------------------------------------------
# _BNGetAllTagReferences
_BNGetAllTagReferences = core.BNGetAllTagReferences
_BNGetAllTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAllTagReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllTagReferences(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAllTagReferences(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllTagReferencesOfType
_BNGetAllTagReferencesOfType = core.BNGetAllTagReferencesOfType
_BNGetAllTagReferencesOfType.restype = ctypes.POINTER(BNTagReference)
_BNGetAllTagReferencesOfType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllTagReferencesOfType(
view: ctypes.POINTER(BNBinaryView),
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAllTagReferencesOfType(view, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllTagReferencesOfTypeCount
_BNGetAllTagReferencesOfTypeCount = core.BNGetAllTagReferencesOfTypeCount
_BNGetAllTagReferencesOfTypeCount.restype = ctypes.c_ulonglong
_BNGetAllTagReferencesOfTypeCount.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNGetAllTagReferencesOfTypeCount(
view: ctypes.POINTER(BNBinaryView),
tagType: ctypes.POINTER(BNTagType)
) -> int:
return _BNGetAllTagReferencesOfTypeCount(view, tagType)
# -------------------------------------------------------
# _BNGetAllTypesReferenced
_BNGetAllTypesReferenced = core.BNGetAllTypesReferenced
_BNGetAllTypesReferenced.restype = ctypes.POINTER(BNTypeFieldReferenceTypeInfo)
_BNGetAllTypesReferenced.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllTypesReferenced(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeFieldReferenceTypeInfo)]:
result = _BNGetAllTypesReferenced(view, type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllUserVariableValues
_BNGetAllUserVariableValues = core.BNGetAllUserVariableValues
_BNGetAllUserVariableValues.restype = ctypes.POINTER(BNUserVariableValue)
_BNGetAllUserVariableValues.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllUserVariableValues(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNUserVariableValue)]:
result = _BNGetAllUserVariableValues(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAllocatedRanges
_BNGetAllocatedRanges = core.BNGetAllocatedRanges
_BNGetAllocatedRanges.restype = ctypes.POINTER(BNAddressRange)
_BNGetAllocatedRanges.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAllocatedRanges(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNAddressRange)]:
result = _BNGetAllocatedRanges(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisAutoTypeContainer
_BNGetAnalysisAutoTypeContainer = core.BNGetAnalysisAutoTypeContainer
_BNGetAnalysisAutoTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetAnalysisAutoTypeContainer.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetAnalysisAutoTypeContainer(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNTypeContainer)]:
result = _BNGetAnalysisAutoTypeContainer(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisDependencySortedTypeList
_BNGetAnalysisDependencySortedTypeList = core.BNGetAnalysisDependencySortedTypeList
_BNGetAnalysisDependencySortedTypeList.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetAnalysisDependencySortedTypeList.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAnalysisDependencySortedTypeList(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
result = _BNGetAnalysisDependencySortedTypeList(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisEntryPoint
_BNGetAnalysisEntryPoint = core.BNGetAnalysisEntryPoint
_BNGetAnalysisEntryPoint.restype = ctypes.POINTER(BNFunction)
_BNGetAnalysisEntryPoint.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetAnalysisEntryPoint(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetAnalysisEntryPoint(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisFunction
_BNGetAnalysisFunction = core.BNGetAnalysisFunction
_BNGetAnalysisFunction.restype = ctypes.POINTER(BNFunction)
_BNGetAnalysisFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNPlatform),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetAnalysisFunction(
view: ctypes.POINTER(BNBinaryView),
platform: ctypes.POINTER(BNPlatform),
addr: int
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetAnalysisFunction(view, platform, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisFunctionList
_BNGetAnalysisFunctionList = core.BNGetAnalysisFunctionList
_BNGetAnalysisFunctionList.restype = ctypes.POINTER(ctypes.POINTER(BNFunction))
_BNGetAnalysisFunctionList.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAnalysisFunctionList(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFunction))]:
result = _BNGetAnalysisFunctionList(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisFunctionsContainingAddress
_BNGetAnalysisFunctionsContainingAddress = core.BNGetAnalysisFunctionsContainingAddress
_BNGetAnalysisFunctionsContainingAddress.restype = ctypes.POINTER(ctypes.POINTER(BNFunction))
_BNGetAnalysisFunctionsContainingAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAnalysisFunctionsContainingAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFunction))]:
result = _BNGetAnalysisFunctionsContainingAddress(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisFunctionsForAddress
_BNGetAnalysisFunctionsForAddress = core.BNGetAnalysisFunctionsForAddress
_BNGetAnalysisFunctionsForAddress.restype = ctypes.POINTER(ctypes.POINTER(BNFunction))
_BNGetAnalysisFunctionsForAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAnalysisFunctionsForAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFunction))]:
result = _BNGetAnalysisFunctionsForAddress(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisInfo
_BNGetAnalysisInfo = core.BNGetAnalysisInfo
_BNGetAnalysisInfo.restype = ctypes.POINTER(BNAnalysisInfo)
_BNGetAnalysisInfo.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetAnalysisInfo(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNAnalysisInfo)]:
result = _BNGetAnalysisInfo(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisProgress
_BNGetAnalysisProgress = core.BNGetAnalysisProgress
_BNGetAnalysisProgress.restype = BNAnalysisProgress
_BNGetAnalysisProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetAnalysisProgress(
view: ctypes.POINTER(BNBinaryView)
) -> BNAnalysisProgress:
return _BNGetAnalysisProgress(view)
# -------------------------------------------------------
# _BNGetAnalysisSkipReason
_BNGetAnalysisSkipReason = core.BNGetAnalysisSkipReason
_BNGetAnalysisSkipReason.restype = AnalysisSkipReasonEnum
_BNGetAnalysisSkipReason.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetAnalysisSkipReason(
func: ctypes.POINTER(BNFunction)
) -> AnalysisSkipReason:
return _BNGetAnalysisSkipReason(func)
# -------------------------------------------------------
# _BNGetAnalysisTypeById
_BNGetAnalysisTypeById = core.BNGetAnalysisTypeById
_BNGetAnalysisTypeById.restype = ctypes.POINTER(BNType)
_BNGetAnalysisTypeById.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetAnalysisTypeById(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str]
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetAnalysisTypeById(view, cstr(id))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisTypeByName
_BNGetAnalysisTypeByName = core.BNGetAnalysisTypeByName
_BNGetAnalysisTypeByName.restype = ctypes.POINTER(BNType)
_BNGetAnalysisTypeByName.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGetAnalysisTypeByName(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetAnalysisTypeByName(view, name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisTypeByRef
_BNGetAnalysisTypeByRef = core.BNGetAnalysisTypeByRef
_BNGetAnalysisTypeByRef.restype = ctypes.POINTER(BNType)
_BNGetAnalysisTypeByRef.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNNamedTypeReference),
]
# noinspection PyPep8Naming
def BNGetAnalysisTypeByRef(
view: ctypes.POINTER(BNBinaryView),
ref: ctypes.POINTER(BNNamedTypeReference)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetAnalysisTypeByRef(view, ref)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisTypeContainer
_BNGetAnalysisTypeContainer = core.BNGetAnalysisTypeContainer
_BNGetAnalysisTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetAnalysisTypeContainer.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetAnalysisTypeContainer(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNTypeContainer)]:
result = _BNGetAnalysisTypeContainer(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisTypeId
_BNGetAnalysisTypeId = core.BNGetAnalysisTypeId
_BNGetAnalysisTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetAnalysisTypeId.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGetAnalysisTypeId(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[Optional[str]]:
result = _BNGetAnalysisTypeId(view, name)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetAnalysisTypeList
_BNGetAnalysisTypeList = core.BNGetAnalysisTypeList
_BNGetAnalysisTypeList.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetAnalysisTypeList.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAnalysisTypeList(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
result = _BNGetAnalysisTypeList(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisTypeNameById
_BNGetAnalysisTypeNameById = core.BNGetAnalysisTypeNameById
_BNGetAnalysisTypeNameById.restype = BNQualifiedName
_BNGetAnalysisTypeNameById.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetAnalysisTypeNameById(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str]
) -> BNQualifiedName:
return _BNGetAnalysisTypeNameById(view, cstr(id))
# -------------------------------------------------------
# _BNGetAnalysisTypeNames
_BNGetAnalysisTypeNames = core.BNGetAnalysisTypeNames
_BNGetAnalysisTypeNames.restype = ctypes.POINTER(BNQualifiedName)
_BNGetAnalysisTypeNames.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetAnalysisTypeNames(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong),
matching: Optional[str]
) -> Optional[ctypes.POINTER(BNQualifiedName)]:
result = _BNGetAnalysisTypeNames(view, count, cstr(matching))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAnalysisUserTypeContainer
_BNGetAnalysisUserTypeContainer = core.BNGetAnalysisUserTypeContainer
_BNGetAnalysisUserTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetAnalysisUserTypeContainer.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetAnalysisUserTypeContainer(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNTypeContainer)]:
result = _BNGetAnalysisUserTypeContainer(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureAddressSize
_BNGetArchitectureAddressSize = core.BNGetArchitectureAddressSize
_BNGetArchitectureAddressSize.restype = ctypes.c_ulonglong
_BNGetArchitectureAddressSize.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureAddressSize(
arch: ctypes.POINTER(BNArchitecture)
) -> int:
return _BNGetArchitectureAddressSize(arch)
# -------------------------------------------------------
# _BNGetArchitectureByName
_BNGetArchitectureByName = core.BNGetArchitectureByName
_BNGetArchitectureByName.restype = ctypes.POINTER(BNArchitecture)
_BNGetArchitectureByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetArchitectureByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetArchitectureByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureCallingConventionByName
_BNGetArchitectureCallingConventionByName = core.BNGetArchitectureCallingConventionByName
_BNGetArchitectureCallingConventionByName.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureCallingConventionByName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetArchitectureCallingConventionByName(
arch: ctypes.POINTER(BNArchitecture),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetArchitectureCallingConventionByName(arch, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureCallingConventions
_BNGetArchitectureCallingConventions = core.BNGetArchitectureCallingConventions
_BNGetArchitectureCallingConventions.restype = ctypes.POINTER(ctypes.POINTER(BNCallingConvention))
_BNGetArchitectureCallingConventions.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureCallingConventions(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNCallingConvention))]:
result = _BNGetArchitectureCallingConventions(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureCdeclCallingConvention
_BNGetArchitectureCdeclCallingConvention = core.BNGetArchitectureCdeclCallingConvention
_BNGetArchitectureCdeclCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureCdeclCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureCdeclCallingConvention(
arch: ctypes.POINTER(BNArchitecture)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetArchitectureCdeclCallingConvention(arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureDefaultCallingConvention
_BNGetArchitectureDefaultCallingConvention = core.BNGetArchitectureDefaultCallingConvention
_BNGetArchitectureDefaultCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureDefaultCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureDefaultCallingConvention(
arch: ctypes.POINTER(BNArchitecture)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetArchitectureDefaultCallingConvention(arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureDefaultIntegerSize
_BNGetArchitectureDefaultIntegerSize = core.BNGetArchitectureDefaultIntegerSize
_BNGetArchitectureDefaultIntegerSize.restype = ctypes.c_ulonglong
_BNGetArchitectureDefaultIntegerSize.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureDefaultIntegerSize(
arch: ctypes.POINTER(BNArchitecture)
) -> int:
return _BNGetArchitectureDefaultIntegerSize(arch)
# -------------------------------------------------------
# _BNGetArchitectureEndianness
_BNGetArchitectureEndianness = core.BNGetArchitectureEndianness
_BNGetArchitectureEndianness.restype = EndiannessEnum
_BNGetArchitectureEndianness.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureEndianness(
arch: ctypes.POINTER(BNArchitecture)
) -> Endianness:
return _BNGetArchitectureEndianness(arch)
# -------------------------------------------------------
# _BNGetArchitectureFastcallCallingConvention
_BNGetArchitectureFastcallCallingConvention = core.BNGetArchitectureFastcallCallingConvention
_BNGetArchitectureFastcallCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureFastcallCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureFastcallCallingConvention(
arch: ctypes.POINTER(BNArchitecture)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetArchitectureFastcallCallingConvention(arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureFlagConditionLowLevelIL
_BNGetArchitectureFlagConditionLowLevelIL = core.BNGetArchitectureFlagConditionLowLevelIL
_BNGetArchitectureFlagConditionLowLevelIL.restype = ctypes.c_ulonglong
_BNGetArchitectureFlagConditionLowLevelIL.argtypes = [
ctypes.POINTER(BNArchitecture),
LowLevelILFlagConditionEnum,
ctypes.c_uint,
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetArchitectureFlagConditionLowLevelIL(
arch: ctypes.POINTER(BNArchitecture),
cond: LowLevelILFlagCondition,
semClass: int,
il: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNGetArchitectureFlagConditionLowLevelIL(arch, cond, semClass, il)
# -------------------------------------------------------
# _BNGetArchitectureFlagConditionsForSemanticFlagGroup
_BNGetArchitectureFlagConditionsForSemanticFlagGroup = core.BNGetArchitectureFlagConditionsForSemanticFlagGroup
_BNGetArchitectureFlagConditionsForSemanticFlagGroup.restype = ctypes.POINTER(BNFlagConditionForSemanticClass)
_BNGetArchitectureFlagConditionsForSemanticFlagGroup.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureFlagConditionsForSemanticFlagGroup(
arch: ctypes.POINTER(BNArchitecture),
semGroup: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNFlagConditionForSemanticClass)]:
result = _BNGetArchitectureFlagConditionsForSemanticFlagGroup(arch, semGroup, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureFlagName
_BNGetArchitectureFlagName = core.BNGetArchitectureFlagName
_BNGetArchitectureFlagName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureFlagName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureFlagName(
arch: ctypes.POINTER(BNArchitecture),
flag: int
) -> Optional[Optional[str]]:
result = _BNGetArchitectureFlagName(arch, flag)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetArchitectureFlagRole
_BNGetArchitectureFlagRole = core.BNGetArchitectureFlagRole
_BNGetArchitectureFlagRole.restype = FlagRoleEnum
_BNGetArchitectureFlagRole.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureFlagRole(
arch: ctypes.POINTER(BNArchitecture),
flag: int,
semClass: int
) -> FlagRole:
return _BNGetArchitectureFlagRole(arch, flag, semClass)
# -------------------------------------------------------
# _BNGetArchitectureFlagWriteLowLevelIL
_BNGetArchitectureFlagWriteLowLevelIL = core.BNGetArchitectureFlagWriteLowLevelIL
_BNGetArchitectureFlagWriteLowLevelIL.restype = ctypes.c_ulonglong
_BNGetArchitectureFlagWriteLowLevelIL.argtypes = [
ctypes.POINTER(BNArchitecture),
LowLevelILOperationEnum,
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.c_uint,
ctypes.POINTER(BNRegisterOrConstant),
ctypes.c_ulonglong,
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetArchitectureFlagWriteLowLevelIL(
arch: ctypes.POINTER(BNArchitecture),
op: LowLevelILOperation,
size: int,
flagWriteType: int,
flag: int,
operands: ctypes.POINTER(BNRegisterOrConstant),
operandCount: int,
il: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNGetArchitectureFlagWriteLowLevelIL(arch, op, size, flagWriteType, flag, operands, operandCount, il)
# -------------------------------------------------------
# _BNGetArchitectureFlagWriteTypeName
_BNGetArchitectureFlagWriteTypeName = core.BNGetArchitectureFlagWriteTypeName
_BNGetArchitectureFlagWriteTypeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureFlagWriteTypeName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureFlagWriteTypeName(
arch: ctypes.POINTER(BNArchitecture),
flags: int
) -> Optional[Optional[str]]:
result = _BNGetArchitectureFlagWriteTypeName(arch, flags)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetArchitectureFlagsRequiredForFlagCondition
_BNGetArchitectureFlagsRequiredForFlagCondition = core.BNGetArchitectureFlagsRequiredForFlagCondition
_BNGetArchitectureFlagsRequiredForFlagCondition.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureFlagsRequiredForFlagCondition.argtypes = [
ctypes.POINTER(BNArchitecture),
LowLevelILFlagConditionEnum,
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureFlagsRequiredForFlagCondition(
arch: ctypes.POINTER(BNArchitecture),
cond: LowLevelILFlagCondition,
semClass: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetArchitectureFlagsRequiredForFlagCondition(arch, cond, semClass, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureFlagsRequiredForSemanticFlagGroup
_BNGetArchitectureFlagsRequiredForSemanticFlagGroup = core.BNGetArchitectureFlagsRequiredForSemanticFlagGroup
_BNGetArchitectureFlagsRequiredForSemanticFlagGroup.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureFlagsRequiredForSemanticFlagGroup.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureFlagsRequiredForSemanticFlagGroup(
arch: ctypes.POINTER(BNArchitecture),
semGroup: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetArchitectureFlagsRequiredForSemanticFlagGroup(arch, semGroup, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureFlagsWrittenByFlagWriteType
_BNGetArchitectureFlagsWrittenByFlagWriteType = core.BNGetArchitectureFlagsWrittenByFlagWriteType
_BNGetArchitectureFlagsWrittenByFlagWriteType.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureFlagsWrittenByFlagWriteType.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureFlagsWrittenByFlagWriteType(
arch: ctypes.POINTER(BNArchitecture),
writeType: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetArchitectureFlagsWrittenByFlagWriteType(arch, writeType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureForViewType
_BNGetArchitectureForViewType = core.BNGetArchitectureForViewType
_BNGetArchitectureForViewType.restype = ctypes.POINTER(BNArchitecture)
_BNGetArchitectureForViewType.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.c_uint,
EndiannessEnum,
]
# noinspection PyPep8Naming
def BNGetArchitectureForViewType(
type: ctypes.POINTER(BNBinaryViewType),
id: int,
endian: Endianness
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetArchitectureForViewType(type, id, endian)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureGlobalRegisters
_BNGetArchitectureGlobalRegisters = core.BNGetArchitectureGlobalRegisters
_BNGetArchitectureGlobalRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureGlobalRegisters.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureGlobalRegisters(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetArchitectureGlobalRegisters(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureInstructionAlignment
_BNGetArchitectureInstructionAlignment = core.BNGetArchitectureInstructionAlignment
_BNGetArchitectureInstructionAlignment.restype = ctypes.c_ulonglong
_BNGetArchitectureInstructionAlignment.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureInstructionAlignment(
arch: ctypes.POINTER(BNArchitecture)
) -> int:
return _BNGetArchitectureInstructionAlignment(arch)
# -------------------------------------------------------
# _BNGetArchitectureIntrinsicClass
_BNGetArchitectureIntrinsicClass = core.BNGetArchitectureIntrinsicClass
_BNGetArchitectureIntrinsicClass.restype = IntrinsicClassEnum
_BNGetArchitectureIntrinsicClass.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureIntrinsicClass(
arch: ctypes.POINTER(BNArchitecture),
intrinsic: int
) -> IntrinsicClass:
return _BNGetArchitectureIntrinsicClass(arch, intrinsic)
# -------------------------------------------------------
# _BNGetArchitectureIntrinsicInputs
_BNGetArchitectureIntrinsicInputs = core.BNGetArchitectureIntrinsicInputs
_BNGetArchitectureIntrinsicInputs.restype = ctypes.POINTER(BNNameAndType)
_BNGetArchitectureIntrinsicInputs.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureIntrinsicInputs(
arch: ctypes.POINTER(BNArchitecture),
intrinsic: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNNameAndType)]:
result = _BNGetArchitectureIntrinsicInputs(arch, intrinsic, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureIntrinsicName
_BNGetArchitectureIntrinsicName = core.BNGetArchitectureIntrinsicName
_BNGetArchitectureIntrinsicName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureIntrinsicName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureIntrinsicName(
arch: ctypes.POINTER(BNArchitecture),
intrinsic: int
) -> Optional[Optional[str]]:
result = _BNGetArchitectureIntrinsicName(arch, intrinsic)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetArchitectureIntrinsicOutputs
_BNGetArchitectureIntrinsicOutputs = core.BNGetArchitectureIntrinsicOutputs
_BNGetArchitectureIntrinsicOutputs.restype = ctypes.POINTER(BNTypeWithConfidence)
_BNGetArchitectureIntrinsicOutputs.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureIntrinsicOutputs(
arch: ctypes.POINTER(BNArchitecture),
intrinsic: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeWithConfidence)]:
result = _BNGetArchitectureIntrinsicOutputs(arch, intrinsic, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureLinkRegister
_BNGetArchitectureLinkRegister = core.BNGetArchitectureLinkRegister
_BNGetArchitectureLinkRegister.restype = ctypes.c_uint
_BNGetArchitectureLinkRegister.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureLinkRegister(
arch: ctypes.POINTER(BNArchitecture)
) -> int:
return _BNGetArchitectureLinkRegister(arch)
# -------------------------------------------------------
# _BNGetArchitectureList
_BNGetArchitectureList = core.BNGetArchitectureList
_BNGetArchitectureList.restype = ctypes.POINTER(ctypes.POINTER(BNArchitecture))
_BNGetArchitectureList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNArchitecture))]:
result = _BNGetArchitectureList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureMaxInstructionLength
_BNGetArchitectureMaxInstructionLength = core.BNGetArchitectureMaxInstructionLength
_BNGetArchitectureMaxInstructionLength.restype = ctypes.c_ulonglong
_BNGetArchitectureMaxInstructionLength.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureMaxInstructionLength(
arch: ctypes.POINTER(BNArchitecture)
) -> int:
return _BNGetArchitectureMaxInstructionLength(arch)
# -------------------------------------------------------
# _BNGetArchitectureName
_BNGetArchitectureName = core.BNGetArchitectureName
_BNGetArchitectureName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureName.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureName(
arch: ctypes.POINTER(BNArchitecture)
) -> Optional[Optional[str]]:
result = _BNGetArchitectureName(arch)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetArchitectureOpcodeDisplayLength
_BNGetArchitectureOpcodeDisplayLength = core.BNGetArchitectureOpcodeDisplayLength
_BNGetArchitectureOpcodeDisplayLength.restype = ctypes.c_ulonglong
_BNGetArchitectureOpcodeDisplayLength.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureOpcodeDisplayLength(
arch: ctypes.POINTER(BNArchitecture)
) -> int:
return _BNGetArchitectureOpcodeDisplayLength(arch)
# -------------------------------------------------------
# _BNGetArchitectureRegisterByName
_BNGetArchitectureRegisterByName = core.BNGetArchitectureRegisterByName
_BNGetArchitectureRegisterByName.restype = ctypes.c_uint
_BNGetArchitectureRegisterByName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetArchitectureRegisterByName(
arch: ctypes.POINTER(BNArchitecture),
name: Optional[str]
) -> int:
return _BNGetArchitectureRegisterByName(arch, cstr(name))
# -------------------------------------------------------
# _BNGetArchitectureRegisterInfo
_BNGetArchitectureRegisterInfo = core.BNGetArchitectureRegisterInfo
_BNGetArchitectureRegisterInfo.restype = BNRegisterInfo
_BNGetArchitectureRegisterInfo.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureRegisterInfo(
arch: ctypes.POINTER(BNArchitecture),
reg: int
) -> BNRegisterInfo:
return _BNGetArchitectureRegisterInfo(arch, reg)
# -------------------------------------------------------
# _BNGetArchitectureRegisterName
_BNGetArchitectureRegisterName = core.BNGetArchitectureRegisterName
_BNGetArchitectureRegisterName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureRegisterName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureRegisterName(
arch: ctypes.POINTER(BNArchitecture),
reg: int
) -> Optional[Optional[str]]:
result = _BNGetArchitectureRegisterName(arch, reg)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetArchitectureRegisterStackForRegister
_BNGetArchitectureRegisterStackForRegister = core.BNGetArchitectureRegisterStackForRegister
_BNGetArchitectureRegisterStackForRegister.restype = ctypes.c_uint
_BNGetArchitectureRegisterStackForRegister.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureRegisterStackForRegister(
arch: ctypes.POINTER(BNArchitecture),
reg: int
) -> int:
return _BNGetArchitectureRegisterStackForRegister(arch, reg)
# -------------------------------------------------------
# _BNGetArchitectureRegisterStackInfo
_BNGetArchitectureRegisterStackInfo = core.BNGetArchitectureRegisterStackInfo
_BNGetArchitectureRegisterStackInfo.restype = BNRegisterStackInfo
_BNGetArchitectureRegisterStackInfo.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureRegisterStackInfo(
arch: ctypes.POINTER(BNArchitecture),
regStack: int
) -> BNRegisterStackInfo:
return _BNGetArchitectureRegisterStackInfo(arch, regStack)
# -------------------------------------------------------
# _BNGetArchitectureRegisterStackName
_BNGetArchitectureRegisterStackName = core.BNGetArchitectureRegisterStackName
_BNGetArchitectureRegisterStackName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureRegisterStackName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureRegisterStackName(
arch: ctypes.POINTER(BNArchitecture),
regStack: int
) -> Optional[Optional[str]]:
result = _BNGetArchitectureRegisterStackName(arch, regStack)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetArchitectureSemanticClassForFlagWriteType
_BNGetArchitectureSemanticClassForFlagWriteType = core.BNGetArchitectureSemanticClassForFlagWriteType
_BNGetArchitectureSemanticClassForFlagWriteType.restype = ctypes.c_uint
_BNGetArchitectureSemanticClassForFlagWriteType.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureSemanticClassForFlagWriteType(
arch: ctypes.POINTER(BNArchitecture),
writeType: int
) -> int:
return _BNGetArchitectureSemanticClassForFlagWriteType(arch, writeType)
# -------------------------------------------------------
# _BNGetArchitectureSemanticFlagClassName
_BNGetArchitectureSemanticFlagClassName = core.BNGetArchitectureSemanticFlagClassName
_BNGetArchitectureSemanticFlagClassName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureSemanticFlagClassName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureSemanticFlagClassName(
arch: ctypes.POINTER(BNArchitecture),
semClass: int
) -> Optional[Optional[str]]:
result = _BNGetArchitectureSemanticFlagClassName(arch, semClass)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetArchitectureSemanticFlagGroupLowLevelIL
_BNGetArchitectureSemanticFlagGroupLowLevelIL = core.BNGetArchitectureSemanticFlagGroupLowLevelIL
_BNGetArchitectureSemanticFlagGroupLowLevelIL.restype = ctypes.c_ulonglong
_BNGetArchitectureSemanticFlagGroupLowLevelIL.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetArchitectureSemanticFlagGroupLowLevelIL(
arch: ctypes.POINTER(BNArchitecture),
semGroup: int,
il: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNGetArchitectureSemanticFlagGroupLowLevelIL(arch, semGroup, il)
# -------------------------------------------------------
# _BNGetArchitectureSemanticFlagGroupName
_BNGetArchitectureSemanticFlagGroupName = core.BNGetArchitectureSemanticFlagGroupName
_BNGetArchitectureSemanticFlagGroupName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetArchitectureSemanticFlagGroupName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetArchitectureSemanticFlagGroupName(
arch: ctypes.POINTER(BNArchitecture),
semGroup: int
) -> Optional[Optional[str]]:
result = _BNGetArchitectureSemanticFlagGroupName(arch, semGroup)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetArchitectureStackPointerRegister
_BNGetArchitectureStackPointerRegister = core.BNGetArchitectureStackPointerRegister
_BNGetArchitectureStackPointerRegister.restype = ctypes.c_uint
_BNGetArchitectureStackPointerRegister.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureStackPointerRegister(
arch: ctypes.POINTER(BNArchitecture)
) -> int:
return _BNGetArchitectureStackPointerRegister(arch)
# -------------------------------------------------------
# _BNGetArchitectureStandalonePlatform
_BNGetArchitectureStandalonePlatform = core.BNGetArchitectureStandalonePlatform
_BNGetArchitectureStandalonePlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetArchitectureStandalonePlatform.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureStandalonePlatform(
arch: ctypes.POINTER(BNArchitecture)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNGetArchitectureStandalonePlatform(arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureStdcallCallingConvention
_BNGetArchitectureStdcallCallingConvention = core.BNGetArchitectureStdcallCallingConvention
_BNGetArchitectureStdcallCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetArchitectureStdcallCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetArchitectureStdcallCallingConvention(
arch: ctypes.POINTER(BNArchitecture)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetArchitectureStdcallCallingConvention(arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureSystemRegisters
_BNGetArchitectureSystemRegisters = core.BNGetArchitectureSystemRegisters
_BNGetArchitectureSystemRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetArchitectureSystemRegisters.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureSystemRegisters(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetArchitectureSystemRegisters(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetArchitectureTypeLibraries
_BNGetArchitectureTypeLibraries = core.BNGetArchitectureTypeLibraries
_BNGetArchitectureTypeLibraries.restype = ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))
_BNGetArchitectureTypeLibraries.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetArchitectureTypeLibraries(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))]:
result = _BNGetArchitectureTypeLibraries(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAssociatedArchitectureByAddress
_BNGetAssociatedArchitectureByAddress = core.BNGetAssociatedArchitectureByAddress
_BNGetAssociatedArchitectureByAddress.restype = ctypes.POINTER(BNArchitecture)
_BNGetAssociatedArchitectureByAddress.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAssociatedArchitectureByAddress(
arch: ctypes.POINTER(BNArchitecture),
addr: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetAssociatedArchitectureByAddress(arch, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAssociatedPlatformByAddress
_BNGetAssociatedPlatformByAddress = core.BNGetAssociatedPlatformByAddress
_BNGetAssociatedPlatformByAddress.restype = ctypes.POINTER(BNPlatform)
_BNGetAssociatedPlatformByAddress.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAssociatedPlatformByAddress(
platform: ctypes.POINTER(BNPlatform),
addr: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNGetAssociatedPlatformByAddress(platform, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoAddressTagReferences
_BNGetAutoAddressTagReferences = core.BNGetAutoAddressTagReferences
_BNGetAutoAddressTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoAddressTagReferences.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoAddressTagReferences(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAutoAddressTagReferences(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoAddressTags
_BNGetAutoAddressTags = core.BNGetAutoAddressTags
_BNGetAutoAddressTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoAddressTags.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoAddressTags(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetAutoAddressTags(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoAddressTagsInRange
_BNGetAutoAddressTagsInRange = core.BNGetAutoAddressTagsInRange
_BNGetAutoAddressTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoAddressTagsInRange.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoAddressTagsInRange(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
start: int,
end: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAutoAddressTagsInRange(func, arch, start, end, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoAddressTagsOfType
_BNGetAutoAddressTagsOfType = core.BNGetAutoAddressTagsOfType
_BNGetAutoAddressTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoAddressTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoAddressTagsOfType(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetAutoAddressTagsOfType(func, arch, addr, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoDataTagReferences
_BNGetAutoDataTagReferences = core.BNGetAutoDataTagReferences
_BNGetAutoDataTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoDataTagReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoDataTagReferences(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAutoDataTagReferences(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoDataTags
_BNGetAutoDataTags = core.BNGetAutoDataTags
_BNGetAutoDataTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoDataTags.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoDataTags(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetAutoDataTags(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoDataTagsInRange
_BNGetAutoDataTagsInRange = core.BNGetAutoDataTagsInRange
_BNGetAutoDataTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoDataTagsInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoDataTagsInRange(
view: ctypes.POINTER(BNBinaryView),
start: int,
end: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAutoDataTagsInRange(view, start, end, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoDataTagsOfType
_BNGetAutoDataTagsOfType = core.BNGetAutoDataTagsOfType
_BNGetAutoDataTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoDataTagsOfType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoDataTagsOfType(
view: ctypes.POINTER(BNBinaryView),
addr: int,
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetAutoDataTagsOfType(view, addr, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoDebugTypeIdSource
_BNGetAutoDebugTypeIdSource = core.BNGetAutoDebugTypeIdSource
_BNGetAutoDebugTypeIdSource.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetAutoDebugTypeIdSource.argtypes = [
]
# noinspection PyPep8Naming
def BNGetAutoDebugTypeIdSource(
) -> Optional[Optional[str]]:
result = _BNGetAutoDebugTypeIdSource()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetAutoDemangledTypeIdSource
_BNGetAutoDemangledTypeIdSource = core.BNGetAutoDemangledTypeIdSource
_BNGetAutoDemangledTypeIdSource.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetAutoDemangledTypeIdSource.argtypes = [
]
# noinspection PyPep8Naming
def BNGetAutoDemangledTypeIdSource(
) -> Optional[Optional[str]]:
result = _BNGetAutoDemangledTypeIdSource()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetAutoFunctionTagReferences
_BNGetAutoFunctionTagReferences = core.BNGetAutoFunctionTagReferences
_BNGetAutoFunctionTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetAutoFunctionTagReferences.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoFunctionTagReferences(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetAutoFunctionTagReferences(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoFunctionTags
_BNGetAutoFunctionTags = core.BNGetAutoFunctionTags
_BNGetAutoFunctionTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoFunctionTags.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoFunctionTags(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetAutoFunctionTags(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoFunctionTagsOfType
_BNGetAutoFunctionTagsOfType = core.BNGetAutoFunctionTagsOfType
_BNGetAutoFunctionTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetAutoFunctionTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetAutoFunctionTagsOfType(
func: ctypes.POINTER(BNFunction),
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetAutoFunctionTagsOfType(func, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetAutoPlatformTypeIdSource
_BNGetAutoPlatformTypeIdSource = core.BNGetAutoPlatformTypeIdSource
_BNGetAutoPlatformTypeIdSource.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetAutoPlatformTypeIdSource.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetAutoPlatformTypeIdSource(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[Optional[str]]:
result = _BNGetAutoPlatformTypeIdSource(platform)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetBackgroundAnalysisTask
_BNGetBackgroundAnalysisTask = core.BNGetBackgroundAnalysisTask
_BNGetBackgroundAnalysisTask.restype = ctypes.POINTER(BNBackgroundTask)
_BNGetBackgroundAnalysisTask.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetBackgroundAnalysisTask(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNBackgroundTask)]:
result = _BNGetBackgroundAnalysisTask(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBackgroundTaskProgressText
_BNGetBackgroundTaskProgressText = core.BNGetBackgroundTaskProgressText
_BNGetBackgroundTaskProgressText.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetBackgroundTaskProgressText.argtypes = [
ctypes.POINTER(BNBackgroundTask),
]
# noinspection PyPep8Naming
def BNGetBackgroundTaskProgressText(
task: ctypes.POINTER(BNBackgroundTask)
) -> Optional[Optional[str]]:
result = _BNGetBackgroundTaskProgressText(task)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetBackgroundTaskRuntimeSeconds
_BNGetBackgroundTaskRuntimeSeconds = core.BNGetBackgroundTaskRuntimeSeconds
_BNGetBackgroundTaskRuntimeSeconds.restype = ctypes.c_ulonglong
_BNGetBackgroundTaskRuntimeSeconds.argtypes = [
ctypes.POINTER(BNBackgroundTask),
]
# noinspection PyPep8Naming
def BNGetBackgroundTaskRuntimeSeconds(
task: ctypes.POINTER(BNBackgroundTask)
) -> int:
return _BNGetBackgroundTaskRuntimeSeconds(task)
# -------------------------------------------------------
# _BNGetBaseStructuresForStructure
_BNGetBaseStructuresForStructure = core.BNGetBaseStructuresForStructure
_BNGetBaseStructuresForStructure.restype = ctypes.POINTER(BNBaseStructure)
_BNGetBaseStructuresForStructure.argtypes = [
ctypes.POINTER(BNStructure),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBaseStructuresForStructure(
s: ctypes.POINTER(BNStructure),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNBaseStructure)]:
result = _BNGetBaseStructuresForStructure(s, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBaseStructuresForStructureBuilder
_BNGetBaseStructuresForStructureBuilder = core.BNGetBaseStructuresForStructureBuilder
_BNGetBaseStructuresForStructureBuilder.restype = ctypes.POINTER(BNBaseStructure)
_BNGetBaseStructuresForStructureBuilder.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBaseStructuresForStructureBuilder(
s: ctypes.POINTER(BNStructureBuilder),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNBaseStructure)]:
result = _BNGetBaseStructuresForStructureBuilder(s, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockArchitecture
_BNGetBasicBlockArchitecture = core.BNGetBasicBlockArchitecture
_BNGetBasicBlockArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetBasicBlockArchitecture.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockArchitecture(
block: ctypes.POINTER(BNBasicBlock)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetBasicBlockArchitecture(block)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockDisassemblyText
_BNGetBasicBlockDisassemblyText = core.BNGetBasicBlockDisassemblyText
_BNGetBasicBlockDisassemblyText.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetBasicBlockDisassemblyText.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.POINTER(BNDisassemblySettings),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBasicBlockDisassemblyText(
block: ctypes.POINTER(BNBasicBlock),
settings: ctypes.POINTER(BNDisassemblySettings),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
result = _BNGetBasicBlockDisassemblyText(block, settings, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockDominanceFrontier
_BNGetBasicBlockDominanceFrontier = core.BNGetBasicBlockDominanceFrontier
_BNGetBasicBlockDominanceFrontier.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockDominanceFrontier.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNGetBasicBlockDominanceFrontier(
block: ctypes.POINTER(BNBasicBlock),
count: ctypes.POINTER(ctypes.c_ulonglong),
post: bool
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetBasicBlockDominanceFrontier(block, count, post)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockDominatorTreeChildren
_BNGetBasicBlockDominatorTreeChildren = core.BNGetBasicBlockDominatorTreeChildren
_BNGetBasicBlockDominatorTreeChildren.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockDominatorTreeChildren.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNGetBasicBlockDominatorTreeChildren(
block: ctypes.POINTER(BNBasicBlock),
count: ctypes.POINTER(ctypes.c_ulonglong),
post: bool
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetBasicBlockDominatorTreeChildren(block, count, post)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockDominators
_BNGetBasicBlockDominators = core.BNGetBasicBlockDominators
_BNGetBasicBlockDominators.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockDominators.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNGetBasicBlockDominators(
block: ctypes.POINTER(BNBasicBlock),
count: ctypes.POINTER(ctypes.c_ulonglong),
post: bool
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetBasicBlockDominators(block, count, post)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockEnd
_BNGetBasicBlockEnd = core.BNGetBasicBlockEnd
_BNGetBasicBlockEnd.restype = ctypes.c_ulonglong
_BNGetBasicBlockEnd.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockEnd(
block: ctypes.POINTER(BNBasicBlock)
) -> int:
return _BNGetBasicBlockEnd(block)
# -------------------------------------------------------
# _BNGetBasicBlockFunction
_BNGetBasicBlockFunction = core.BNGetBasicBlockFunction
_BNGetBasicBlockFunction.restype = ctypes.POINTER(BNFunction)
_BNGetBasicBlockFunction.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockFunction(
block: ctypes.POINTER(BNBasicBlock)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetBasicBlockFunction(block)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockFunctionGraphType
_BNGetBasicBlockFunctionGraphType = core.BNGetBasicBlockFunctionGraphType
_BNGetBasicBlockFunctionGraphType.restype = FunctionGraphTypeEnum
_BNGetBasicBlockFunctionGraphType.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockFunctionGraphType(
block: ctypes.POINTER(BNBasicBlock)
) -> FunctionGraphType:
return _BNGetBasicBlockFunctionGraphType(block)
# -------------------------------------------------------
# _BNGetBasicBlockHighLevelILFunction
_BNGetBasicBlockHighLevelILFunction = core.BNGetBasicBlockHighLevelILFunction
_BNGetBasicBlockHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetBasicBlockHighLevelILFunction.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockHighLevelILFunction(
block: ctypes.POINTER(BNBasicBlock)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNGetBasicBlockHighLevelILFunction(block)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockHighlight
_BNGetBasicBlockHighlight = core.BNGetBasicBlockHighlight
_BNGetBasicBlockHighlight.restype = BNHighlightColor
_BNGetBasicBlockHighlight.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockHighlight(
block: ctypes.POINTER(BNBasicBlock)
) -> BNHighlightColor:
return _BNGetBasicBlockHighlight(block)
# -------------------------------------------------------
# _BNGetBasicBlockImmediateDominator
_BNGetBasicBlockImmediateDominator = core.BNGetBasicBlockImmediateDominator
_BNGetBasicBlockImmediateDominator.restype = ctypes.POINTER(BNBasicBlock)
_BNGetBasicBlockImmediateDominator.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNGetBasicBlockImmediateDominator(
block: ctypes.POINTER(BNBasicBlock),
post: bool
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetBasicBlockImmediateDominator(block, post)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockIncomingEdges
_BNGetBasicBlockIncomingEdges = core.BNGetBasicBlockIncomingEdges
_BNGetBasicBlockIncomingEdges.restype = ctypes.POINTER(BNBasicBlockEdge)
_BNGetBasicBlockIncomingEdges.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBasicBlockIncomingEdges(
block: ctypes.POINTER(BNBasicBlock),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNBasicBlockEdge)]:
result = _BNGetBasicBlockIncomingEdges(block, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockIndex
_BNGetBasicBlockIndex = core.BNGetBasicBlockIndex
_BNGetBasicBlockIndex.restype = ctypes.c_ulonglong
_BNGetBasicBlockIndex.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockIndex(
block: ctypes.POINTER(BNBasicBlock)
) -> int:
return _BNGetBasicBlockIndex(block)
# -------------------------------------------------------
# _BNGetBasicBlockInstructionContainingAddress
_BNGetBasicBlockInstructionContainingAddress = core.BNGetBasicBlockInstructionContainingAddress
_BNGetBasicBlockInstructionContainingAddress.restype = ctypes.c_bool
_BNGetBasicBlockInstructionContainingAddress.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBasicBlockInstructionContainingAddress(
block: ctypes.POINTER(BNBasicBlock),
addr: int,
start: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetBasicBlockInstructionContainingAddress(block, addr, start)
# -------------------------------------------------------
# _BNGetBasicBlockIteratedDominanceFrontier
_BNGetBasicBlockIteratedDominanceFrontier = core.BNGetBasicBlockIteratedDominanceFrontier
_BNGetBasicBlockIteratedDominanceFrontier.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockIteratedDominanceFrontier.argtypes = [
ctypes.POINTER(ctypes.POINTER(BNBasicBlock)),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBasicBlockIteratedDominanceFrontier(
blocks: ctypes.POINTER(ctypes.POINTER(BNBasicBlock)),
incomingCount: int,
outputCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetBasicBlockIteratedDominanceFrontier(blocks, incomingCount, outputCount)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockLength
_BNGetBasicBlockLength = core.BNGetBasicBlockLength
_BNGetBasicBlockLength.restype = ctypes.c_ulonglong
_BNGetBasicBlockLength.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockLength(
block: ctypes.POINTER(BNBasicBlock)
) -> int:
return _BNGetBasicBlockLength(block)
# -------------------------------------------------------
# _BNGetBasicBlockLowLevelILFunction
_BNGetBasicBlockLowLevelILFunction = core.BNGetBasicBlockLowLevelILFunction
_BNGetBasicBlockLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetBasicBlockLowLevelILFunction.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockLowLevelILFunction(
block: ctypes.POINTER(BNBasicBlock)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetBasicBlockLowLevelILFunction(block)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockMediumLevelILFunction
_BNGetBasicBlockMediumLevelILFunction = core.BNGetBasicBlockMediumLevelILFunction
_BNGetBasicBlockMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetBasicBlockMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockMediumLevelILFunction(
block: ctypes.POINTER(BNBasicBlock)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetBasicBlockMediumLevelILFunction(block)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockOutgoingEdges
_BNGetBasicBlockOutgoingEdges = core.BNGetBasicBlockOutgoingEdges
_BNGetBasicBlockOutgoingEdges.restype = ctypes.POINTER(BNBasicBlockEdge)
_BNGetBasicBlockOutgoingEdges.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBasicBlockOutgoingEdges(
block: ctypes.POINTER(BNBasicBlock),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNBasicBlockEdge)]:
result = _BNGetBasicBlockOutgoingEdges(block, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockSource
_BNGetBasicBlockSource = core.BNGetBasicBlockSource
_BNGetBasicBlockSource.restype = ctypes.POINTER(BNBasicBlock)
_BNGetBasicBlockSource.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockSource(
block: ctypes.POINTER(BNBasicBlock)
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetBasicBlockSource(block)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockSourceBlock
_BNGetBasicBlockSourceBlock = core.BNGetBasicBlockSourceBlock
_BNGetBasicBlockSourceBlock.restype = ctypes.POINTER(BNBasicBlock)
_BNGetBasicBlockSourceBlock.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockSourceBlock(
block: ctypes.POINTER(BNBasicBlock)
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetBasicBlockSourceBlock(block)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlockStart
_BNGetBasicBlockStart = core.BNGetBasicBlockStart
_BNGetBasicBlockStart.restype = ctypes.c_ulonglong
_BNGetBasicBlockStart.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNGetBasicBlockStart(
block: ctypes.POINTER(BNBasicBlock)
) -> int:
return _BNGetBasicBlockStart(block)
# -------------------------------------------------------
# _BNGetBasicBlockStrictDominators
_BNGetBasicBlockStrictDominators = core.BNGetBasicBlockStrictDominators
_BNGetBasicBlockStrictDominators.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlockStrictDominators.argtypes = [
ctypes.POINTER(BNBasicBlock),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNGetBasicBlockStrictDominators(
block: ctypes.POINTER(BNBasicBlock),
count: ctypes.POINTER(ctypes.c_ulonglong),
post: bool
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetBasicBlockStrictDominators(block, count, post)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlocksForAddress
_BNGetBasicBlocksForAddress = core.BNGetBasicBlocksForAddress
_BNGetBasicBlocksForAddress.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlocksForAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBasicBlocksForAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetBasicBlocksForAddress(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBasicBlocksStartingAtAddress
_BNGetBasicBlocksStartingAtAddress = core.BNGetBasicBlocksStartingAtAddress
_BNGetBasicBlocksStartingAtAddress.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetBasicBlocksStartingAtAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBasicBlocksStartingAtAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetBasicBlocksStartingAtAddress(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBinaryReaderEndianness
_BNGetBinaryReaderEndianness = core.BNGetBinaryReaderEndianness
_BNGetBinaryReaderEndianness.restype = EndiannessEnum
_BNGetBinaryReaderEndianness.argtypes = [
ctypes.POINTER(BNBinaryReader),
]
# noinspection PyPep8Naming
def BNGetBinaryReaderEndianness(
stream: ctypes.POINTER(BNBinaryReader)
) -> Endianness:
return _BNGetBinaryReaderEndianness(stream)
# -------------------------------------------------------
# _BNGetBinaryReaderVirtualBase
_BNGetBinaryReaderVirtualBase = core.BNGetBinaryReaderVirtualBase
_BNGetBinaryReaderVirtualBase.restype = ctypes.c_ulonglong
_BNGetBinaryReaderVirtualBase.argtypes = [
ctypes.POINTER(BNBinaryReader),
]
# noinspection PyPep8Naming
def BNGetBinaryReaderVirtualBase(
stream: ctypes.POINTER(BNBinaryReader)
) -> int:
return _BNGetBinaryReaderVirtualBase(stream)
# -------------------------------------------------------
# _BNGetBinaryViewDefaultLoadSettingsForData
_BNGetBinaryViewDefaultLoadSettingsForData = core.BNGetBinaryViewDefaultLoadSettingsForData
_BNGetBinaryViewDefaultLoadSettingsForData.restype = ctypes.POINTER(BNSettings)
_BNGetBinaryViewDefaultLoadSettingsForData.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetBinaryViewDefaultLoadSettingsForData(
type: ctypes.POINTER(BNBinaryViewType),
data: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNSettings)]:
result = _BNGetBinaryViewDefaultLoadSettingsForData(type, data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBinaryViewLoadSettingsForData
_BNGetBinaryViewLoadSettingsForData = core.BNGetBinaryViewLoadSettingsForData
_BNGetBinaryViewLoadSettingsForData.restype = ctypes.POINTER(BNSettings)
_BNGetBinaryViewLoadSettingsForData.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetBinaryViewLoadSettingsForData(
type: ctypes.POINTER(BNBinaryViewType),
data: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNSettings)]:
result = _BNGetBinaryViewLoadSettingsForData(type, data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBinaryViewTypeByName
_BNGetBinaryViewTypeByName = core.BNGetBinaryViewTypeByName
_BNGetBinaryViewTypeByName.restype = ctypes.POINTER(BNBinaryViewType)
_BNGetBinaryViewTypeByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetBinaryViewTypeByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNBinaryViewType)]:
result = _BNGetBinaryViewTypeByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBinaryViewTypeLibraries
_BNGetBinaryViewTypeLibraries = core.BNGetBinaryViewTypeLibraries
_BNGetBinaryViewTypeLibraries.restype = ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))
_BNGetBinaryViewTypeLibraries.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBinaryViewTypeLibraries(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))]:
result = _BNGetBinaryViewTypeLibraries(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBinaryViewTypeLibrary
_BNGetBinaryViewTypeLibrary = core.BNGetBinaryViewTypeLibrary
_BNGetBinaryViewTypeLibrary.restype = ctypes.POINTER(BNTypeLibrary)
_BNGetBinaryViewTypeLibrary.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetBinaryViewTypeLibrary(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
result = _BNGetBinaryViewTypeLibrary(view, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBinaryViewTypeLongName
_BNGetBinaryViewTypeLongName = core.BNGetBinaryViewTypeLongName
_BNGetBinaryViewTypeLongName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetBinaryViewTypeLongName.argtypes = [
ctypes.POINTER(BNBinaryViewType),
]
# noinspection PyPep8Naming
def BNGetBinaryViewTypeLongName(
type: ctypes.POINTER(BNBinaryViewType)
) -> Optional[Optional[str]]:
result = _BNGetBinaryViewTypeLongName(type)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetBinaryViewTypeName
_BNGetBinaryViewTypeName = core.BNGetBinaryViewTypeName
_BNGetBinaryViewTypeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetBinaryViewTypeName.argtypes = [
ctypes.POINTER(BNBinaryViewType),
]
# noinspection PyPep8Naming
def BNGetBinaryViewTypeName(
type: ctypes.POINTER(BNBinaryViewType)
) -> Optional[Optional[str]]:
result = _BNGetBinaryViewTypeName(type)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetBinaryViewTypes
_BNGetBinaryViewTypes = core.BNGetBinaryViewTypes
_BNGetBinaryViewTypes.restype = ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))
_BNGetBinaryViewTypes.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBinaryViewTypes(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))]:
result = _BNGetBinaryViewTypes(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBinaryViewTypesForData
_BNGetBinaryViewTypesForData = core.BNGetBinaryViewTypesForData
_BNGetBinaryViewTypesForData.restype = ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))
_BNGetBinaryViewTypesForData.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetBinaryViewTypesForData(
data: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBinaryViewType))]:
result = _BNGetBinaryViewTypesForData(data, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetBinaryWriterEndianness
_BNGetBinaryWriterEndianness = core.BNGetBinaryWriterEndianness
_BNGetBinaryWriterEndianness.restype = EndiannessEnum
_BNGetBinaryWriterEndianness.argtypes = [
ctypes.POINTER(BNBinaryWriter),
]
# noinspection PyPep8Naming
def BNGetBinaryWriterEndianness(
stream: ctypes.POINTER(BNBinaryWriter)
) -> Endianness:
return _BNGetBinaryWriterEndianness(stream)
# -------------------------------------------------------
# _BNGetBuildId
_BNGetBuildId = core.BNGetBuildId
_BNGetBuildId.restype = ctypes.c_uint
_BNGetBuildId.argtypes = [
]
# noinspection PyPep8Naming
def BNGetBuildId(
) -> int:
return _BNGetBuildId()
# -------------------------------------------------------
# _BNGetBundledPluginDirectory
_BNGetBundledPluginDirectory = core.BNGetBundledPluginDirectory
_BNGetBundledPluginDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetBundledPluginDirectory.argtypes = [
]
# noinspection PyPep8Naming
def BNGetBundledPluginDirectory(
) -> Optional[Optional[str]]:
result = _BNGetBundledPluginDirectory()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetCallRegisterStackAdjustment
_BNGetCallRegisterStackAdjustment = core.BNGetCallRegisterStackAdjustment
_BNGetCallRegisterStackAdjustment.restype = ctypes.POINTER(BNRegisterStackAdjustment)
_BNGetCallRegisterStackAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCallRegisterStackAdjustment(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNRegisterStackAdjustment)]:
result = _BNGetCallRegisterStackAdjustment(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCallRegisterStackAdjustmentForRegisterStack
_BNGetCallRegisterStackAdjustmentForRegisterStack = core.BNGetCallRegisterStackAdjustmentForRegisterStack
_BNGetCallRegisterStackAdjustmentForRegisterStack.restype = BNRegisterStackAdjustment
_BNGetCallRegisterStackAdjustmentForRegisterStack.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetCallRegisterStackAdjustmentForRegisterStack(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
regStack: int
) -> BNRegisterStackAdjustment:
return _BNGetCallRegisterStackAdjustmentForRegisterStack(func, arch, addr, regStack)
# -------------------------------------------------------
# _BNGetCallStackAdjustment
_BNGetCallStackAdjustment = core.BNGetCallStackAdjustment
_BNGetCallStackAdjustment.restype = BNOffsetWithConfidence
_BNGetCallStackAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetCallStackAdjustment(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> BNOffsetWithConfidence:
return _BNGetCallStackAdjustment(func, arch, addr)
# -------------------------------------------------------
# _BNGetCallTypeAdjustment
_BNGetCallTypeAdjustment = core.BNGetCallTypeAdjustment
_BNGetCallTypeAdjustment.restype = BNTypeWithConfidence
_BNGetCallTypeAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetCallTypeAdjustment(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> BNTypeWithConfidence:
return _BNGetCallTypeAdjustment(func, arch, addr)
# -------------------------------------------------------
# _BNGetCalleeSavedRegisters
_BNGetCalleeSavedRegisters = core.BNGetCalleeSavedRegisters
_BNGetCalleeSavedRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetCalleeSavedRegisters.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCalleeSavedRegisters(
cc: ctypes.POINTER(BNCallingConvention),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetCalleeSavedRegisters(cc, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCallees
_BNGetCallees = core.BNGetCallees
_BNGetCallees.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetCallees.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNReferenceSource),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCallees(
view: ctypes.POINTER(BNBinaryView),
callSite: ctypes.POINTER(BNReferenceSource),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetCallees(view, callSite, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCallerSavedRegisters
_BNGetCallerSavedRegisters = core.BNGetCallerSavedRegisters
_BNGetCallerSavedRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetCallerSavedRegisters.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCallerSavedRegisters(
cc: ctypes.POINTER(BNCallingConvention),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetCallerSavedRegisters(cc, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCallers
_BNGetCallers = core.BNGetCallers
_BNGetCallers.restype = ctypes.POINTER(BNReferenceSource)
_BNGetCallers.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCallers(
view: ctypes.POINTER(BNBinaryView),
callee: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNReferenceSource)]:
result = _BNGetCallers(view, callee, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCallingConventionArchitecture
_BNGetCallingConventionArchitecture = core.BNGetCallingConventionArchitecture
_BNGetCallingConventionArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetCallingConventionArchitecture.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNGetCallingConventionArchitecture(
cc: ctypes.POINTER(BNCallingConvention)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetCallingConventionArchitecture(cc)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCallingConventionName
_BNGetCallingConventionName = core.BNGetCallingConventionName
_BNGetCallingConventionName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetCallingConventionName.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNGetCallingConventionName(
cc: ctypes.POINTER(BNCallingConvention)
) -> Optional[Optional[str]]:
result = _BNGetCallingConventionName(cc)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetChildType
_BNGetChildType = core.BNGetChildType
_BNGetChildType.restype = BNTypeWithConfidence
_BNGetChildType.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetChildType(
type: ctypes.POINTER(BNType)
) -> BNTypeWithConfidence:
return _BNGetChildType(type)
# -------------------------------------------------------
# _BNGetChoiceInput
_BNGetChoiceInput = core.BNGetChoiceInput
_BNGetChoiceInput.restype = ctypes.c_bool
_BNGetChoiceInput.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetChoiceInput(
result: ctypes.POINTER(ctypes.c_ulonglong),
prompt: Optional[str],
title: Optional[str],
choices: ctypes.POINTER(ctypes.c_char_p),
count: int
) -> bool:
return _BNGetChoiceInput(result, cstr(prompt), cstr(title), choices, count)
# -------------------------------------------------------
# _BNGetCodeReferences
_BNGetCodeReferences = core.BNGetCodeReferences
_BNGetCodeReferences.restype = ctypes.POINTER(BNReferenceSource)
_BNGetCodeReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferences(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNReferenceSource)]:
result = _BNGetCodeReferences(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCodeReferencesForType
_BNGetCodeReferencesForType = core.BNGetCodeReferencesForType
_BNGetCodeReferencesForType.restype = ctypes.POINTER(BNReferenceSource)
_BNGetCodeReferencesForType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferencesForType(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNReferenceSource)]:
result = _BNGetCodeReferencesForType(view, type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCodeReferencesForTypeField
_BNGetCodeReferencesForTypeField = core.BNGetCodeReferencesForTypeField
_BNGetCodeReferencesForTypeField.restype = ctypes.POINTER(BNTypeFieldReference)
_BNGetCodeReferencesForTypeField.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeField(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
offset: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeFieldReference)]:
result = _BNGetCodeReferencesForTypeField(view, type, offset, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCodeReferencesForTypeFieldsFrom
_BNGetCodeReferencesForTypeFieldsFrom = core.BNGetCodeReferencesForTypeFieldsFrom
_BNGetCodeReferencesForTypeFieldsFrom.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetCodeReferencesForTypeFieldsFrom.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNReferenceSource),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeFieldsFrom(
view: ctypes.POINTER(BNBinaryView),
addr: ctypes.POINTER(BNReferenceSource),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
result = _BNGetCodeReferencesForTypeFieldsFrom(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCodeReferencesForTypeFieldsFromInRange
_BNGetCodeReferencesForTypeFieldsFromInRange = core.BNGetCodeReferencesForTypeFieldsFromInRange
_BNGetCodeReferencesForTypeFieldsFromInRange.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetCodeReferencesForTypeFieldsFromInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNReferenceSource),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeFieldsFromInRange(
view: ctypes.POINTER(BNBinaryView),
addr: ctypes.POINTER(BNReferenceSource),
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
result = _BNGetCodeReferencesForTypeFieldsFromInRange(view, addr, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCodeReferencesForTypeFrom
_BNGetCodeReferencesForTypeFrom = core.BNGetCodeReferencesForTypeFrom
_BNGetCodeReferencesForTypeFrom.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetCodeReferencesForTypeFrom.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNReferenceSource),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeFrom(
view: ctypes.POINTER(BNBinaryView),
addr: ctypes.POINTER(BNReferenceSource),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
result = _BNGetCodeReferencesForTypeFrom(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCodeReferencesForTypeFromInRange
_BNGetCodeReferencesForTypeFromInRange = core.BNGetCodeReferencesForTypeFromInRange
_BNGetCodeReferencesForTypeFromInRange.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetCodeReferencesForTypeFromInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNReferenceSource),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferencesForTypeFromInRange(
view: ctypes.POINTER(BNBinaryView),
addr: ctypes.POINTER(BNReferenceSource),
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
result = _BNGetCodeReferencesForTypeFromInRange(view, addr, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCodeReferencesFrom
_BNGetCodeReferencesFrom = core.BNGetCodeReferencesFrom
_BNGetCodeReferencesFrom.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetCodeReferencesFrom.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNReferenceSource),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferencesFrom(
view: ctypes.POINTER(BNBinaryView),
src: ctypes.POINTER(BNReferenceSource),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetCodeReferencesFrom(view, src, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCodeReferencesFromInRange
_BNGetCodeReferencesFromInRange = core.BNGetCodeReferencesFromInRange
_BNGetCodeReferencesFromInRange.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetCodeReferencesFromInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNReferenceSource),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferencesFromInRange(
view: ctypes.POINTER(BNBinaryView),
src: ctypes.POINTER(BNReferenceSource),
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetCodeReferencesFromInRange(view, src, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCodeReferencesInRange
_BNGetCodeReferencesInRange = core.BNGetCodeReferencesInRange
_BNGetCodeReferencesInRange.restype = ctypes.POINTER(BNReferenceSource)
_BNGetCodeReferencesInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCodeReferencesInRange(
view: ctypes.POINTER(BNBinaryView),
addr: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNReferenceSource)]:
result = _BNGetCodeReferencesInRange(view, addr, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCommentForAddress
_BNGetCommentForAddress = core.BNGetCommentForAddress
_BNGetCommentForAddress.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetCommentForAddress.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetCommentForAddress(
func: ctypes.POINTER(BNFunction),
addr: int
) -> Optional[Optional[str]]:
result = _BNGetCommentForAddress(func, addr)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetCommentedAddresses
_BNGetCommentedAddresses = core.BNGetCommentedAddresses
_BNGetCommentedAddresses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetCommentedAddresses.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetCommentedAddresses(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetCommentedAddresses(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetComponentByGuid
_BNGetComponentByGuid = core.BNGetComponentByGuid
_BNGetComponentByGuid.restype = ctypes.POINTER(BNComponent)
_BNGetComponentByGuid.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetComponentByGuid(
view: ctypes.POINTER(BNBinaryView),
guid: Optional[str]
) -> Optional[ctypes.POINTER(BNComponent)]:
result = _BNGetComponentByGuid(view, cstr(guid))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetComponentByPath
_BNGetComponentByPath = core.BNGetComponentByPath
_BNGetComponentByPath.restype = ctypes.POINTER(BNComponent)
_BNGetComponentByPath.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetComponentByPath(
view: ctypes.POINTER(BNBinaryView),
path: Optional[str]
) -> Optional[ctypes.POINTER(BNComponent)]:
result = _BNGetComponentByPath(view, cstr(path))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetConstantData
_BNGetConstantData = core.BNGetConstantData
_BNGetConstantData.restype = ctypes.POINTER(BNDataBuffer)
_BNGetConstantData.argtypes = [
ctypes.POINTER(BNFunction),
RegisterValueTypeEnum,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetConstantData(
func: ctypes.POINTER(BNFunction),
state: RegisterValueType,
value: int,
size: int
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNGetConstantData(func, state, value, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetConstantsReferencedByInstruction
_BNGetConstantsReferencedByInstruction = core.BNGetConstantsReferencedByInstruction
_BNGetConstantsReferencedByInstruction.restype = ctypes.POINTER(BNConstantReference)
_BNGetConstantsReferencedByInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetConstantsReferencedByInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNConstantReference)]:
result = _BNGetConstantsReferencedByInstruction(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetConstantsReferencedByInstructionIfAvailable
_BNGetConstantsReferencedByInstructionIfAvailable = core.BNGetConstantsReferencedByInstructionIfAvailable
_BNGetConstantsReferencedByInstructionIfAvailable.restype = ctypes.POINTER(BNConstantReference)
_BNGetConstantsReferencedByInstructionIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetConstantsReferencedByInstructionIfAvailable(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNConstantReference)]:
result = _BNGetConstantsReferencedByInstructionIfAvailable(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetCurrentCoreABIVersion
_BNGetCurrentCoreABIVersion = core.BNGetCurrentCoreABIVersion
_BNGetCurrentCoreABIVersion.restype = ctypes.c_uint
_BNGetCurrentCoreABIVersion.argtypes = [
]
# noinspection PyPep8Naming
def BNGetCurrentCoreABIVersion(
) -> int:
return _BNGetCurrentCoreABIVersion()
# -------------------------------------------------------
# _BNGetCurrentOffset
_BNGetCurrentOffset = core.BNGetCurrentOffset
_BNGetCurrentOffset.restype = ctypes.c_ulonglong
_BNGetCurrentOffset.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetCurrentOffset(
file: ctypes.POINTER(BNFileMetadata)
) -> int:
return _BNGetCurrentOffset(file)
# -------------------------------------------------------
# _BNGetCurrentStackTraceString
_BNGetCurrentStackTraceString = core.BNGetCurrentStackTraceString
_BNGetCurrentStackTraceString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetCurrentStackTraceString.argtypes = [
]
# noinspection PyPep8Naming
def BNGetCurrentStackTraceString(
) -> Optional[Optional[str]]:
result = _BNGetCurrentStackTraceString()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetCurrentView
_BNGetCurrentView = core.BNGetCurrentView
_BNGetCurrentView.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetCurrentView.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetCurrentView(
file: ctypes.POINTER(BNFileMetadata)
) -> Optional[Optional[str]]:
result = _BNGetCurrentView(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetDataBufferByte
_BNGetDataBufferByte = core.BNGetDataBufferByte
_BNGetDataBufferByte.restype = ctypes.c_ubyte
_BNGetDataBufferByte.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetDataBufferByte(
buf: ctypes.POINTER(BNDataBuffer),
offset: int
) -> int:
return _BNGetDataBufferByte(buf, offset)
# -------------------------------------------------------
# _BNGetDataBufferContents
_BNGetDataBufferContents = core.BNGetDataBufferContents
_BNGetDataBufferContents.restype = ctypes.c_void_p
_BNGetDataBufferContents.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNGetDataBufferContents(
buf: ctypes.POINTER(BNDataBuffer)
) -> Optional[Optional[ctypes.c_void_p]]:
result = _BNGetDataBufferContents(buf)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataBufferContentsAt
_BNGetDataBufferContentsAt = core.BNGetDataBufferContentsAt
_BNGetDataBufferContentsAt.restype = ctypes.c_void_p
_BNGetDataBufferContentsAt.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetDataBufferContentsAt(
buf: ctypes.POINTER(BNDataBuffer),
offset: int
) -> Optional[Optional[ctypes.c_void_p]]:
result = _BNGetDataBufferContentsAt(buf, offset)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataBufferLength
_BNGetDataBufferLength = core.BNGetDataBufferLength
_BNGetDataBufferLength.restype = ctypes.c_ulonglong
_BNGetDataBufferLength.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNGetDataBufferLength(
buf: ctypes.POINTER(BNDataBuffer)
) -> int:
return _BNGetDataBufferLength(buf)
# -------------------------------------------------------
# _BNGetDataBufferSlice
_BNGetDataBufferSlice = core.BNGetDataBufferSlice
_BNGetDataBufferSlice.restype = ctypes.POINTER(BNDataBuffer)
_BNGetDataBufferSlice.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetDataBufferSlice(
buf: ctypes.POINTER(BNDataBuffer),
start: int,
len: int
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNGetDataBufferSlice(buf, start, len)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataReferences
_BNGetDataReferences = core.BNGetDataReferences
_BNGetDataReferences.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataReferences(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetDataReferences(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataReferencesForType
_BNGetDataReferencesForType = core.BNGetDataReferencesForType
_BNGetDataReferencesForType.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesForType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataReferencesForType(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetDataReferencesForType(view, type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataReferencesForTypeField
_BNGetDataReferencesForTypeField = core.BNGetDataReferencesForTypeField
_BNGetDataReferencesForTypeField.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesForTypeField.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataReferencesForTypeField(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
offset: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetDataReferencesForTypeField(view, type, offset, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataReferencesFrom
_BNGetDataReferencesFrom = core.BNGetDataReferencesFrom
_BNGetDataReferencesFrom.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesFrom.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataReferencesFrom(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetDataReferencesFrom(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataReferencesFromForTypeField
_BNGetDataReferencesFromForTypeField = core.BNGetDataReferencesFromForTypeField
_BNGetDataReferencesFromForTypeField.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesFromForTypeField.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataReferencesFromForTypeField(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
offset: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetDataReferencesFromForTypeField(view, type, offset, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataReferencesFromInRange
_BNGetDataReferencesFromInRange = core.BNGetDataReferencesFromInRange
_BNGetDataReferencesFromInRange.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesFromInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataReferencesFromInRange(
view: ctypes.POINTER(BNBinaryView),
addr: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetDataReferencesFromInRange(view, addr, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataReferencesInRange
_BNGetDataReferencesInRange = core.BNGetDataReferencesInRange
_BNGetDataReferencesInRange.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetDataReferencesInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataReferencesInRange(
view: ctypes.POINTER(BNBinaryView),
addr: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetDataReferencesInRange(view, addr, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataRendererContainer
_BNGetDataRendererContainer = core.BNGetDataRendererContainer
_BNGetDataRendererContainer.restype = ctypes.POINTER(BNDataRendererContainer)
_BNGetDataRendererContainer.argtypes = [
]
# noinspection PyPep8Naming
def BNGetDataRendererContainer(
) -> Optional[ctypes.POINTER(BNDataRendererContainer)]:
result = _BNGetDataRendererContainer()
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataTagReferences
_BNGetDataTagReferences = core.BNGetDataTagReferences
_BNGetDataTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetDataTagReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataTagReferences(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetDataTagReferences(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataTags
_BNGetDataTags = core.BNGetDataTags
_BNGetDataTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetDataTags.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataTags(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetDataTags(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataTagsInRange
_BNGetDataTagsInRange = core.BNGetDataTagsInRange
_BNGetDataTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetDataTagsInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataTagsInRange(
view: ctypes.POINTER(BNBinaryView),
start: int,
end: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetDataTagsInRange(view, start, end, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataTagsOfType
_BNGetDataTagsOfType = core.BNGetDataTagsOfType
_BNGetDataTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetDataTagsOfType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataTagsOfType(
view: ctypes.POINTER(BNBinaryView),
addr: int,
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetDataTagsOfType(view, addr, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataVariableAtAddress
_BNGetDataVariableAtAddress = core.BNGetDataVariableAtAddress
_BNGetDataVariableAtAddress.restype = ctypes.c_bool
_BNGetDataVariableAtAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNDataVariable),
]
# noinspection PyPep8Naming
def BNGetDataVariableAtAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
var: ctypes.POINTER(BNDataVariable)
) -> bool:
return _BNGetDataVariableAtAddress(view, addr, var)
# -------------------------------------------------------
# _BNGetDataVariableParentComponents
_BNGetDataVariableParentComponents = core.BNGetDataVariableParentComponents
_BNGetDataVariableParentComponents.restype = ctypes.POINTER(ctypes.POINTER(BNComponent))
_BNGetDataVariableParentComponents.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataVariableParentComponents(
view: ctypes.POINTER(BNBinaryView),
dataVariable: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNComponent))]:
result = _BNGetDataVariableParentComponents(view, dataVariable, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDataVariables
_BNGetDataVariables = core.BNGetDataVariables
_BNGetDataVariables.restype = ctypes.POINTER(BNDataVariable)
_BNGetDataVariables.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDataVariables(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDataVariable)]:
result = _BNGetDataVariables(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDatabaseCurrentSnapshot
_BNGetDatabaseCurrentSnapshot = core.BNGetDatabaseCurrentSnapshot
_BNGetDatabaseCurrentSnapshot.restype = ctypes.POINTER(BNSnapshot)
_BNGetDatabaseCurrentSnapshot.argtypes = [
ctypes.POINTER(BNDatabase),
]
# noinspection PyPep8Naming
def BNGetDatabaseCurrentSnapshot(
database: ctypes.POINTER(BNDatabase)
) -> Optional[ctypes.POINTER(BNSnapshot)]:
result = _BNGetDatabaseCurrentSnapshot(database)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDatabaseFile
_BNGetDatabaseFile = core.BNGetDatabaseFile
_BNGetDatabaseFile.restype = ctypes.POINTER(BNFileMetadata)
_BNGetDatabaseFile.argtypes = [
ctypes.POINTER(BNDatabase),
]
# noinspection PyPep8Naming
def BNGetDatabaseFile(
database: ctypes.POINTER(BNDatabase)
) -> Optional[ctypes.POINTER(BNFileMetadata)]:
result = _BNGetDatabaseFile(database)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDatabaseGlobalKeys
_BNGetDatabaseGlobalKeys = core.BNGetDatabaseGlobalKeys
_BNGetDatabaseGlobalKeys.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetDatabaseGlobalKeys.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDatabaseGlobalKeys(
database: ctypes.POINTER(BNDatabase),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetDatabaseGlobalKeys(database, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDatabaseSnapshot
_BNGetDatabaseSnapshot = core.BNGetDatabaseSnapshot
_BNGetDatabaseSnapshot.restype = ctypes.POINTER(BNSnapshot)
_BNGetDatabaseSnapshot.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNGetDatabaseSnapshot(
database: ctypes.POINTER(BNDatabase),
id: int
) -> Optional[ctypes.POINTER(BNSnapshot)]:
result = _BNGetDatabaseSnapshot(database, id)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDatabaseSnapshots
_BNGetDatabaseSnapshots = core.BNGetDatabaseSnapshots
_BNGetDatabaseSnapshots.restype = ctypes.POINTER(ctypes.POINTER(BNSnapshot))
_BNGetDatabaseSnapshots.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDatabaseSnapshots(
database: ctypes.POINTER(BNDatabase),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSnapshot))]:
result = _BNGetDatabaseSnapshots(database, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugDataVariableByAddress
_BNGetDebugDataVariableByAddress = core.BNGetDebugDataVariableByAddress
_BNGetDebugDataVariableByAddress.restype = ctypes.POINTER(BNDataVariableAndName)
_BNGetDebugDataVariableByAddress.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetDebugDataVariableByAddress(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str],
address: int
) -> Optional[ctypes.POINTER(BNDataVariableAndName)]:
result = _BNGetDebugDataVariableByAddress(debugInfo, cstr(parserName), address)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugDataVariableByName
_BNGetDebugDataVariableByName = core.BNGetDebugDataVariableByName
_BNGetDebugDataVariableByName.restype = ctypes.POINTER(BNDataVariableAndName)
_BNGetDebugDataVariableByName.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetDebugDataVariableByName(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str],
variableName: Optional[str]
) -> Optional[ctypes.POINTER(BNDataVariableAndName)]:
result = _BNGetDebugDataVariableByName(debugInfo, cstr(parserName), cstr(variableName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugDataVariables
_BNGetDebugDataVariables = core.BNGetDebugDataVariables
_BNGetDebugDataVariables.restype = ctypes.POINTER(BNDataVariableAndName)
_BNGetDebugDataVariables.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDebugDataVariables(
debugInfo: ctypes.POINTER(BNDebugInfo),
name: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDataVariableAndName)]:
result = _BNGetDebugDataVariables(debugInfo, cstr(name), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugDataVariablesByAddress
_BNGetDebugDataVariablesByAddress = core.BNGetDebugDataVariablesByAddress
_BNGetDebugDataVariablesByAddress.restype = ctypes.POINTER(BNDataVariableAndNameAndDebugParser)
_BNGetDebugDataVariablesByAddress.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDebugDataVariablesByAddress(
debugInfo: ctypes.POINTER(BNDebugInfo),
address: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDataVariableAndNameAndDebugParser)]:
result = _BNGetDebugDataVariablesByAddress(debugInfo, address, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugDataVariablesByName
_BNGetDebugDataVariablesByName = core.BNGetDebugDataVariablesByName
_BNGetDebugDataVariablesByName.restype = ctypes.POINTER(BNDataVariableAndName)
_BNGetDebugDataVariablesByName.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDebugDataVariablesByName(
debugInfo: ctypes.POINTER(BNDebugInfo),
variableName: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDataVariableAndName)]:
result = _BNGetDebugDataVariablesByName(debugInfo, cstr(variableName), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugFunctions
_BNGetDebugFunctions = core.BNGetDebugFunctions
_BNGetDebugFunctions.restype = ctypes.POINTER(BNDebugFunctionInfo)
_BNGetDebugFunctions.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDebugFunctions(
debugInfo: ctypes.POINTER(BNDebugInfo),
name: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDebugFunctionInfo)]:
result = _BNGetDebugFunctions(debugInfo, cstr(name), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugInfo
_BNGetDebugInfo = core.BNGetDebugInfo
_BNGetDebugInfo.restype = ctypes.POINTER(BNDebugInfo)
_BNGetDebugInfo.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetDebugInfo(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNDebugInfo)]:
result = _BNGetDebugInfo(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugInfoParserByName
_BNGetDebugInfoParserByName = core.BNGetDebugInfoParserByName
_BNGetDebugInfoParserByName.restype = ctypes.POINTER(BNDebugInfoParser)
_BNGetDebugInfoParserByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetDebugInfoParserByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNDebugInfoParser)]:
result = _BNGetDebugInfoParserByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugInfoParserName
_BNGetDebugInfoParserName = core.BNGetDebugInfoParserName
_BNGetDebugInfoParserName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetDebugInfoParserName.argtypes = [
ctypes.POINTER(BNDebugInfoParser),
]
# noinspection PyPep8Naming
def BNGetDebugInfoParserName(
parser: ctypes.POINTER(BNDebugInfoParser)
) -> Optional[Optional[str]]:
result = _BNGetDebugInfoParserName(parser)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetDebugInfoParsers
_BNGetDebugInfoParsers = core.BNGetDebugInfoParsers
_BNGetDebugInfoParsers.restype = ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser))
_BNGetDebugInfoParsers.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDebugInfoParsers(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser))]:
result = _BNGetDebugInfoParsers(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugInfoParsersForView
_BNGetDebugInfoParsersForView = core.BNGetDebugInfoParsersForView
_BNGetDebugInfoParsersForView.restype = ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser))
_BNGetDebugInfoParsersForView.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDebugInfoParsersForView(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNDebugInfoParser))]:
result = _BNGetDebugInfoParsersForView(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugInfoTypeContainer
_BNGetDebugInfoTypeContainer = core.BNGetDebugInfoTypeContainer
_BNGetDebugInfoTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetDebugInfoTypeContainer.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetDebugInfoTypeContainer(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeContainer)]:
result = _BNGetDebugInfoTypeContainer(debugInfo, cstr(parserName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugParserNames
_BNGetDebugParserNames = core.BNGetDebugParserNames
_BNGetDebugParserNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetDebugParserNames.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDebugParserNames(
debugInfo: ctypes.POINTER(BNDebugInfo),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetDebugParserNames(debugInfo, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugTypeByName
_BNGetDebugTypeByName = core.BNGetDebugTypeByName
_BNGetDebugTypeByName.restype = ctypes.POINTER(BNType)
_BNGetDebugTypeByName.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetDebugTypeByName(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str],
typeName: Optional[str]
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetDebugTypeByName(debugInfo, cstr(parserName), cstr(typeName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugTypes
_BNGetDebugTypes = core.BNGetDebugTypes
_BNGetDebugTypes.restype = ctypes.POINTER(BNNameAndType)
_BNGetDebugTypes.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDebugTypes(
debugInfo: ctypes.POINTER(BNDebugInfo),
name: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNNameAndType)]:
result = _BNGetDebugTypes(debugInfo, cstr(name), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDebugTypesByName
_BNGetDebugTypesByName = core.BNGetDebugTypesByName
_BNGetDebugTypesByName.restype = ctypes.POINTER(BNNameAndType)
_BNGetDebugTypesByName.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDebugTypesByName(
debugInfo: ctypes.POINTER(BNDebugInfo),
typeName: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNNameAndType)]:
result = _BNGetDebugTypesByName(debugInfo, cstr(typeName), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDefaultArchitecture
_BNGetDefaultArchitecture = core.BNGetDefaultArchitecture
_BNGetDefaultArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetDefaultArchitecture.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetDefaultArchitecture(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetDefaultArchitecture(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDefaultArchitectureFlagConditionLowLevelIL
_BNGetDefaultArchitectureFlagConditionLowLevelIL = core.BNGetDefaultArchitectureFlagConditionLowLevelIL
_BNGetDefaultArchitectureFlagConditionLowLevelIL.restype = ctypes.c_ulonglong
_BNGetDefaultArchitectureFlagConditionLowLevelIL.argtypes = [
ctypes.POINTER(BNArchitecture),
LowLevelILFlagConditionEnum,
ctypes.c_uint,
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetDefaultArchitectureFlagConditionLowLevelIL(
arch: ctypes.POINTER(BNArchitecture),
cond: LowLevelILFlagCondition,
semClass: int,
il: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNGetDefaultArchitectureFlagConditionLowLevelIL(arch, cond, semClass, il)
# -------------------------------------------------------
# _BNGetDefaultArchitectureFlagWriteLowLevelIL
_BNGetDefaultArchitectureFlagWriteLowLevelIL = core.BNGetDefaultArchitectureFlagWriteLowLevelIL
_BNGetDefaultArchitectureFlagWriteLowLevelIL.restype = ctypes.c_ulonglong
_BNGetDefaultArchitectureFlagWriteLowLevelIL.argtypes = [
ctypes.POINTER(BNArchitecture),
LowLevelILOperationEnum,
ctypes.c_ulonglong,
FlagRoleEnum,
ctypes.POINTER(BNRegisterOrConstant),
ctypes.c_ulonglong,
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetDefaultArchitectureFlagWriteLowLevelIL(
arch: ctypes.POINTER(BNArchitecture),
op: LowLevelILOperation,
size: int,
role: FlagRole,
operands: ctypes.POINTER(BNRegisterOrConstant),
operandCount: int,
il: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNGetDefaultArchitectureFlagWriteLowLevelIL(arch, op, size, role, operands, operandCount, il)
# -------------------------------------------------------
# _BNGetDefaultEndianness
_BNGetDefaultEndianness = core.BNGetDefaultEndianness
_BNGetDefaultEndianness.restype = EndiannessEnum
_BNGetDefaultEndianness.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetDefaultEndianness(
view: ctypes.POINTER(BNBinaryView)
) -> Endianness:
return _BNGetDefaultEndianness(view)
# -------------------------------------------------------
# _BNGetDefaultIncomingVariableForParameterVariable
_BNGetDefaultIncomingVariableForParameterVariable = core.BNGetDefaultIncomingVariableForParameterVariable
_BNGetDefaultIncomingVariableForParameterVariable.restype = BNVariable
_BNGetDefaultIncomingVariableForParameterVariable.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNGetDefaultIncomingVariableForParameterVariable(
cc: ctypes.POINTER(BNCallingConvention),
var: ctypes.POINTER(BNVariable)
) -> BNVariable:
return _BNGetDefaultIncomingVariableForParameterVariable(cc, var)
# -------------------------------------------------------
# _BNGetDefaultIndexForMediumLevelILVariableDefinition
_BNGetDefaultIndexForMediumLevelILVariableDefinition = core.BNGetDefaultIndexForMediumLevelILVariableDefinition
_BNGetDefaultIndexForMediumLevelILVariableDefinition.restype = ctypes.c_uint
_BNGetDefaultIndexForMediumLevelILVariableDefinition.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetDefaultIndexForMediumLevelILVariableDefinition(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
instrIndex: int
) -> int:
return _BNGetDefaultIndexForMediumLevelILVariableDefinition(func, var, instrIndex)
# -------------------------------------------------------
# _BNGetDefaultParameterVariableForIncomingVariable
_BNGetDefaultParameterVariableForIncomingVariable = core.BNGetDefaultParameterVariableForIncomingVariable
_BNGetDefaultParameterVariableForIncomingVariable.restype = BNVariable
_BNGetDefaultParameterVariableForIncomingVariable.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNGetDefaultParameterVariableForIncomingVariable(
cc: ctypes.POINTER(BNCallingConvention),
var: ctypes.POINTER(BNVariable)
) -> BNVariable:
return _BNGetDefaultParameterVariableForIncomingVariable(cc, var)
# -------------------------------------------------------
# _BNGetDefaultPlatform
_BNGetDefaultPlatform = core.BNGetDefaultPlatform
_BNGetDefaultPlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetDefaultPlatform.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetDefaultPlatform(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNGetDefaultPlatform(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDefaultTypeParser
_BNGetDefaultTypeParser = core.BNGetDefaultTypeParser
_BNGetDefaultTypeParser.restype = ctypes.POINTER(BNTypeParser)
_BNGetDefaultTypeParser.argtypes = [
]
# noinspection PyPep8Naming
def BNGetDefaultTypeParser(
) -> Optional[ctypes.POINTER(BNTypeParser)]:
result = _BNGetDefaultTypeParser()
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDirectoryNameInput
_BNGetDirectoryNameInput = core.BNGetDirectoryNameInput
_BNGetDirectoryNameInput.restype = ctypes.c_bool
_BNGetDirectoryNameInput.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetDirectoryNameInput(
result: ctypes.POINTER(ctypes.c_char_p),
prompt: Optional[str],
defaultName: Optional[str]
) -> bool:
return _BNGetDirectoryNameInput(result, cstr(prompt), cstr(defaultName))
# -------------------------------------------------------
# _BNGetDisassemblyGutterWidth
_BNGetDisassemblyGutterWidth = core.BNGetDisassemblyGutterWidth
_BNGetDisassemblyGutterWidth.restype = ctypes.c_ulonglong
_BNGetDisassemblyGutterWidth.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNGetDisassemblyGutterWidth(
settings: ctypes.POINTER(BNDisassemblySettings)
) -> int:
return _BNGetDisassemblyGutterWidth(settings)
# -------------------------------------------------------
# _BNGetDisassemblyMaximumSymbolWidth
_BNGetDisassemblyMaximumSymbolWidth = core.BNGetDisassemblyMaximumSymbolWidth
_BNGetDisassemblyMaximumSymbolWidth.restype = ctypes.c_ulonglong
_BNGetDisassemblyMaximumSymbolWidth.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNGetDisassemblyMaximumSymbolWidth(
settings: ctypes.POINTER(BNDisassemblySettings)
) -> int:
return _BNGetDisassemblyMaximumSymbolWidth(settings)
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererArchitecture
_BNGetDisassemblyTextRendererArchitecture = core.BNGetDisassemblyTextRendererArchitecture
_BNGetDisassemblyTextRendererArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetDisassemblyTextRendererArchitecture.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererArchitecture(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetDisassemblyTextRendererArchitecture(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererBasicBlock
_BNGetDisassemblyTextRendererBasicBlock = core.BNGetDisassemblyTextRendererBasicBlock
_BNGetDisassemblyTextRendererBasicBlock.restype = ctypes.POINTER(BNBasicBlock)
_BNGetDisassemblyTextRendererBasicBlock.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererBasicBlock(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetDisassemblyTextRendererBasicBlock(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererFunction
_BNGetDisassemblyTextRendererFunction = core.BNGetDisassemblyTextRendererFunction
_BNGetDisassemblyTextRendererFunction.restype = ctypes.POINTER(BNFunction)
_BNGetDisassemblyTextRendererFunction.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererFunction(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetDisassemblyTextRendererFunction(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererHighLevelILFunction
_BNGetDisassemblyTextRendererHighLevelILFunction = core.BNGetDisassemblyTextRendererHighLevelILFunction
_BNGetDisassemblyTextRendererHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetDisassemblyTextRendererHighLevelILFunction.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererHighLevelILFunction(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNGetDisassemblyTextRendererHighLevelILFunction(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererInstructionAnnotations
_BNGetDisassemblyTextRendererInstructionAnnotations = core.BNGetDisassemblyTextRendererInstructionAnnotations
_BNGetDisassemblyTextRendererInstructionAnnotations.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetDisassemblyTextRendererInstructionAnnotations.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererInstructionAnnotations(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetDisassemblyTextRendererInstructionAnnotations(renderer, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererInstructionText
_BNGetDisassemblyTextRendererInstructionText = core.BNGetDisassemblyTextRendererInstructionText
_BNGetDisassemblyTextRendererInstructionText.restype = ctypes.c_bool
_BNGetDisassemblyTextRendererInstructionText.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.POINTER(BNDisassemblyTextLine)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererInstructionText(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
addr: int,
len: ctypes.POINTER(ctypes.c_ulonglong),
result: ctypes.POINTER(ctypes.POINTER(BNDisassemblyTextLine)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetDisassemblyTextRendererInstructionText(renderer, addr, len, result, count)
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererIntegerTokens
_BNGetDisassemblyTextRendererIntegerTokens = core.BNGetDisassemblyTextRendererIntegerTokens
_BNGetDisassemblyTextRendererIntegerTokens.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetDisassemblyTextRendererIntegerTokens.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.POINTER(BNInstructionTextToken),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererIntegerTokens(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
token: ctypes.POINTER(BNInstructionTextToken),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetDisassemblyTextRendererIntegerTokens(renderer, token, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererLines
_BNGetDisassemblyTextRendererLines = core.BNGetDisassemblyTextRendererLines
_BNGetDisassemblyTextRendererLines.restype = ctypes.c_bool
_BNGetDisassemblyTextRendererLines.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.POINTER(BNDisassemblyTextLine)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererLines(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
addr: int,
len: ctypes.POINTER(ctypes.c_ulonglong),
result: ctypes.POINTER(ctypes.POINTER(BNDisassemblyTextLine)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetDisassemblyTextRendererLines(renderer, addr, len, result, count)
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererLowLevelILFunction
_BNGetDisassemblyTextRendererLowLevelILFunction = core.BNGetDisassemblyTextRendererLowLevelILFunction
_BNGetDisassemblyTextRendererLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetDisassemblyTextRendererLowLevelILFunction.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererLowLevelILFunction(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetDisassemblyTextRendererLowLevelILFunction(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererMediumLevelILFunction
_BNGetDisassemblyTextRendererMediumLevelILFunction = core.BNGetDisassemblyTextRendererMediumLevelILFunction
_BNGetDisassemblyTextRendererMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetDisassemblyTextRendererMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererMediumLevelILFunction(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetDisassemblyTextRendererMediumLevelILFunction(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererSettings
_BNGetDisassemblyTextRendererSettings = core.BNGetDisassemblyTextRendererSettings
_BNGetDisassemblyTextRendererSettings.restype = ctypes.POINTER(BNDisassemblySettings)
_BNGetDisassemblyTextRendererSettings.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererSettings(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> Optional[ctypes.POINTER(BNDisassemblySettings)]:
result = _BNGetDisassemblyTextRendererSettings(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererStackVariableReferenceTokens
_BNGetDisassemblyTextRendererStackVariableReferenceTokens = core.BNGetDisassemblyTextRendererStackVariableReferenceTokens
_BNGetDisassemblyTextRendererStackVariableReferenceTokens.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetDisassemblyTextRendererStackVariableReferenceTokens.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.POINTER(BNStackVariableReference),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererStackVariableReferenceTokens(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
ref: ctypes.POINTER(BNStackVariableReference),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetDisassemblyTextRendererStackVariableReferenceTokens(renderer, ref, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDisassemblyTextRendererSymbolTokens
_BNGetDisassemblyTextRendererSymbolTokens = core.BNGetDisassemblyTextRendererSymbolTokens
_BNGetDisassemblyTextRendererSymbolTokens.restype = ctypes.c_bool
_BNGetDisassemblyTextRendererSymbolTokens.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDisassemblyTextRendererSymbolTokens(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
addr: int,
size: int,
operand: int,
result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetDisassemblyTextRendererSymbolTokens(renderer, addr, size, operand, result, count)
# -------------------------------------------------------
# _BNGetDisassemblyWidth
_BNGetDisassemblyWidth = core.BNGetDisassemblyWidth
_BNGetDisassemblyWidth.restype = ctypes.c_ulonglong
_BNGetDisassemblyWidth.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNGetDisassemblyWidth(
settings: ctypes.POINTER(BNDisassemblySettings)
) -> int:
return _BNGetDisassemblyWidth(settings)
# -------------------------------------------------------
# _BNGetDisplayStringForInteger
_BNGetDisplayStringForInteger = core.BNGetDisplayStringForInteger
_BNGetDisplayStringForInteger.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetDisplayStringForInteger.argtypes = [
ctypes.POINTER(BNBinaryView),
IntegerDisplayTypeEnum,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNGetDisplayStringForInteger(
binaryView: ctypes.POINTER(BNBinaryView),
type: IntegerDisplayType,
value: int,
inputWidth: int,
isSigned: bool
) -> Optional[Optional[str]]:
result = _BNGetDisplayStringForInteger(binaryView, type, value, inputWidth, isSigned)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetDownloadProviderByName
_BNGetDownloadProviderByName = core.BNGetDownloadProviderByName
_BNGetDownloadProviderByName.restype = ctypes.POINTER(BNDownloadProvider)
_BNGetDownloadProviderByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetDownloadProviderByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNDownloadProvider)]:
result = _BNGetDownloadProviderByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDownloadProviderList
_BNGetDownloadProviderList = core.BNGetDownloadProviderList
_BNGetDownloadProviderList.restype = ctypes.POINTER(ctypes.POINTER(BNDownloadProvider))
_BNGetDownloadProviderList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetDownloadProviderList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNDownloadProvider))]:
result = _BNGetDownloadProviderList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetDownloadProviderName
_BNGetDownloadProviderName = core.BNGetDownloadProviderName
_BNGetDownloadProviderName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetDownloadProviderName.argtypes = [
ctypes.POINTER(BNDownloadProvider),
]
# noinspection PyPep8Naming
def BNGetDownloadProviderName(
provider: ctypes.POINTER(BNDownloadProvider)
) -> Optional[Optional[str]]:
result = _BNGetDownloadProviderName(provider)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetEndOffset
_BNGetEndOffset = core.BNGetEndOffset
_BNGetEndOffset.restype = ctypes.c_ulonglong
_BNGetEndOffset.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetEndOffset(
view: ctypes.POINTER(BNBinaryView)
) -> int:
return _BNGetEndOffset(view)
# -------------------------------------------------------
# _BNGetEnterpriseServerAuthenticationMethods
_BNGetEnterpriseServerAuthenticationMethods = core.BNGetEnterpriseServerAuthenticationMethods
_BNGetEnterpriseServerAuthenticationMethods.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerAuthenticationMethods.argtypes = [
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerAuthenticationMethods(
methods: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
names: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p))
) -> int:
return _BNGetEnterpriseServerAuthenticationMethods(methods, names)
# -------------------------------------------------------
# _BNGetEnterpriseServerBuildId
_BNGetEnterpriseServerBuildId = core.BNGetEnterpriseServerBuildId
_BNGetEnterpriseServerBuildId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerBuildId.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerBuildId(
) -> Optional[Optional[str]]:
result = _BNGetEnterpriseServerBuildId()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetEnterpriseServerId
_BNGetEnterpriseServerId = core.BNGetEnterpriseServerId
_BNGetEnterpriseServerId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerId.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerId(
) -> Optional[Optional[str]]:
result = _BNGetEnterpriseServerId()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetEnterpriseServerLastError
_BNGetEnterpriseServerLastError = core.BNGetEnterpriseServerLastError
_BNGetEnterpriseServerLastError.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerLastError.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerLastError(
) -> Optional[Optional[str]]:
result = _BNGetEnterpriseServerLastError()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetEnterpriseServerLicenseDuration
_BNGetEnterpriseServerLicenseDuration = core.BNGetEnterpriseServerLicenseDuration
_BNGetEnterpriseServerLicenseDuration.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerLicenseDuration.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerLicenseDuration(
) -> int:
return _BNGetEnterpriseServerLicenseDuration()
# -------------------------------------------------------
# _BNGetEnterpriseServerLicenseExpirationTime
_BNGetEnterpriseServerLicenseExpirationTime = core.BNGetEnterpriseServerLicenseExpirationTime
_BNGetEnterpriseServerLicenseExpirationTime.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerLicenseExpirationTime.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerLicenseExpirationTime(
) -> int:
return _BNGetEnterpriseServerLicenseExpirationTime()
# -------------------------------------------------------
# _BNGetEnterpriseServerName
_BNGetEnterpriseServerName = core.BNGetEnterpriseServerName
_BNGetEnterpriseServerName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerName.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerName(
) -> Optional[Optional[str]]:
result = _BNGetEnterpriseServerName()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetEnterpriseServerReservationTimeLimit
_BNGetEnterpriseServerReservationTimeLimit = core.BNGetEnterpriseServerReservationTimeLimit
_BNGetEnterpriseServerReservationTimeLimit.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerReservationTimeLimit.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerReservationTimeLimit(
) -> int:
return _BNGetEnterpriseServerReservationTimeLimit()
# -------------------------------------------------------
# _BNGetEnterpriseServerToken
_BNGetEnterpriseServerToken = core.BNGetEnterpriseServerToken
_BNGetEnterpriseServerToken.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerToken.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerToken(
) -> Optional[Optional[str]]:
result = _BNGetEnterpriseServerToken()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetEnterpriseServerUrl
_BNGetEnterpriseServerUrl = core.BNGetEnterpriseServerUrl
_BNGetEnterpriseServerUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerUrl.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerUrl(
) -> Optional[Optional[str]]:
result = _BNGetEnterpriseServerUrl()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetEnterpriseServerUsername
_BNGetEnterpriseServerUsername = core.BNGetEnterpriseServerUsername
_BNGetEnterpriseServerUsername.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetEnterpriseServerUsername.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerUsername(
) -> Optional[Optional[str]]:
result = _BNGetEnterpriseServerUsername()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetEnterpriseServerVersion
_BNGetEnterpriseServerVersion = core.BNGetEnterpriseServerVersion
_BNGetEnterpriseServerVersion.restype = ctypes.c_ulonglong
_BNGetEnterpriseServerVersion.argtypes = [
]
# noinspection PyPep8Naming
def BNGetEnterpriseServerVersion(
) -> int:
return _BNGetEnterpriseServerVersion()
# -------------------------------------------------------
# _BNGetEntropy
_BNGetEntropy = core.BNGetEntropy
_BNGetEntropy.restype = ctypes.c_ulonglong
_BNGetEntropy.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_float),
]
# noinspection PyPep8Naming
def BNGetEntropy(
view: ctypes.POINTER(BNBinaryView),
offset: int,
len: int,
blockSize: int,
result: ctypes.POINTER(ctypes.c_float)
) -> int:
return _BNGetEntropy(view, offset, len, blockSize, result)
# -------------------------------------------------------
# _BNGetEntryPoint
_BNGetEntryPoint = core.BNGetEntryPoint
_BNGetEntryPoint.restype = ctypes.c_ulonglong
_BNGetEntryPoint.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetEntryPoint(
view: ctypes.POINTER(BNBinaryView)
) -> int:
return _BNGetEntryPoint(view)
# -------------------------------------------------------
# _BNGetEnumerationBuilderMembers
_BNGetEnumerationBuilderMembers = core.BNGetEnumerationBuilderMembers
_BNGetEnumerationBuilderMembers.restype = ctypes.POINTER(BNEnumerationMember)
_BNGetEnumerationBuilderMembers.argtypes = [
ctypes.POINTER(BNEnumerationBuilder),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetEnumerationBuilderMembers(
e: ctypes.POINTER(BNEnumerationBuilder),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNEnumerationMember)]:
result = _BNGetEnumerationBuilderMembers(e, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetEnumerationMembers
_BNGetEnumerationMembers = core.BNGetEnumerationMembers
_BNGetEnumerationMembers.restype = ctypes.POINTER(BNEnumerationMember)
_BNGetEnumerationMembers.argtypes = [
ctypes.POINTER(BNEnumeration),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetEnumerationMembers(
e: ctypes.POINTER(BNEnumeration),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNEnumerationMember)]:
result = _BNGetEnumerationMembers(e, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetEnumerationTokensForValue
_BNGetEnumerationTokensForValue = core.BNGetEnumerationTokensForValue
_BNGetEnumerationTokensForValue.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetEnumerationTokensForValue.argtypes = [
ctypes.POINTER(BNEnumeration),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetEnumerationTokensForValue(
e: ctypes.POINTER(BNEnumeration),
value: int,
width: int,
count: ctypes.POINTER(ctypes.c_ulonglong),
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetEnumerationTokensForValue(e, value, width, count, type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetErrorForDownloadInstance
_BNGetErrorForDownloadInstance = core.BNGetErrorForDownloadInstance
_BNGetErrorForDownloadInstance.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetErrorForDownloadInstance.argtypes = [
ctypes.POINTER(BNDownloadInstance),
]
# noinspection PyPep8Naming
def BNGetErrorForDownloadInstance(
instance: ctypes.POINTER(BNDownloadInstance)
) -> Optional[Optional[str]]:
result = _BNGetErrorForDownloadInstance(instance)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetExistingViews
_BNGetExistingViews = core.BNGetExistingViews
_BNGetExistingViews.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetExistingViews.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetExistingViews(
file: ctypes.POINTER(BNFileMetadata),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetExistingViews(file, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetExpressionParserMagicValue
_BNGetExpressionParserMagicValue = core.BNGetExpressionParserMagicValue
_BNGetExpressionParserMagicValue.restype = ctypes.c_bool
_BNGetExpressionParserMagicValue.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetExpressionParserMagicValue(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str],
value: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetExpressionParserMagicValue(view, cstr(name), value)
# -------------------------------------------------------
# _BNGetExternalNameSpace
_BNGetExternalNameSpace = core.BNGetExternalNameSpace
_BNGetExternalNameSpace.restype = BNNameSpace
_BNGetExternalNameSpace.argtypes = [
]
# noinspection PyPep8Naming
def BNGetExternalNameSpace(
) -> BNNameSpace:
return _BNGetExternalNameSpace()
# -------------------------------------------------------
# _BNGetFileExtension
_BNGetFileExtension = core.BNGetFileExtension
_BNGetFileExtension.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetFileExtension.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetFileExtension(
path: Optional[str]
) -> Optional[Optional[str]]:
result = _BNGetFileExtension(cstr(path))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetFileForView
_BNGetFileForView = core.BNGetFileForView
_BNGetFileForView.restype = ctypes.POINTER(BNFileMetadata)
_BNGetFileForView.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetFileForView(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNFileMetadata)]:
result = _BNGetFileForView(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFileMetadataDatabase
_BNGetFileMetadataDatabase = core.BNGetFileMetadataDatabase
_BNGetFileMetadataDatabase.restype = ctypes.POINTER(BNDatabase)
_BNGetFileMetadataDatabase.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetFileMetadataDatabase(
file: ctypes.POINTER(BNFileMetadata)
) -> Optional[ctypes.POINTER(BNDatabase)]:
result = _BNGetFileMetadataDatabase(file)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFileName
_BNGetFileName = core.BNGetFileName
_BNGetFileName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetFileName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetFileName(
path: Optional[str]
) -> Optional[Optional[str]]:
result = _BNGetFileName(cstr(path))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetFilePathsInDirectory
_BNGetFilePathsInDirectory = core.BNGetFilePathsInDirectory
_BNGetFilePathsInDirectory.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetFilePathsInDirectory.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFilePathsInDirectory(
path: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetFilePathsInDirectory(cstr(path), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFileViewOfType
_BNGetFileViewOfType = core.BNGetFileViewOfType
_BNGetFileViewOfType.restype = ctypes.POINTER(BNBinaryView)
_BNGetFileViewOfType.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetFileViewOfType(
file: ctypes.POINTER(BNFileMetadata),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNGetFileViewOfType(file, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFilename
_BNGetFilename = core.BNGetFilename
_BNGetFilename.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetFilename.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetFilename(
file: ctypes.POINTER(BNFileMetadata)
) -> Optional[Optional[str]]:
result = _BNGetFilename(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetFirstLinearViewObjectChild
_BNGetFirstLinearViewObjectChild = core.BNGetFirstLinearViewObjectChild
_BNGetFirstLinearViewObjectChild.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetFirstLinearViewObjectChild.argtypes = [
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNGetFirstLinearViewObjectChild(
obj: ctypes.POINTER(BNLinearViewObject)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNGetFirstLinearViewObjectChild(obj)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlagsReadByLiftedILInstruction
_BNGetFlagsReadByLiftedILInstruction = core.BNGetFlagsReadByLiftedILInstruction
_BNGetFlagsReadByLiftedILInstruction.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetFlagsReadByLiftedILInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFlagsReadByLiftedILInstruction(
func: ctypes.POINTER(BNFunction),
i: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetFlagsReadByLiftedILInstruction(func, i, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlagsWrittenByLiftedILInstruction
_BNGetFlagsWrittenByLiftedILInstruction = core.BNGetFlagsWrittenByLiftedILInstruction
_BNGetFlagsWrittenByLiftedILInstruction.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetFlagsWrittenByLiftedILInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFlagsWrittenByLiftedILInstruction(
func: ctypes.POINTER(BNFunction),
i: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetFlagsWrittenByLiftedILInstruction(func, i, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFloatArgumentRegisters
_BNGetFloatArgumentRegisters = core.BNGetFloatArgumentRegisters
_BNGetFloatArgumentRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetFloatArgumentRegisters.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFloatArgumentRegisters(
cc: ctypes.POINTER(BNCallingConvention),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetFloatArgumentRegisters(cc, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFloatReturnValueRegister
_BNGetFloatReturnValueRegister = core.BNGetFloatReturnValueRegister
_BNGetFloatReturnValueRegister.restype = ctypes.c_uint
_BNGetFloatReturnValueRegister.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNGetFloatReturnValueRegister(
cc: ctypes.POINTER(BNCallingConvention)
) -> int:
return _BNGetFloatReturnValueRegister(cc)
# -------------------------------------------------------
# _BNGetFlowGraphBasicBlock
_BNGetFlowGraphBasicBlock = core.BNGetFlowGraphBasicBlock
_BNGetFlowGraphBasicBlock.restype = ctypes.POINTER(BNBasicBlock)
_BNGetFlowGraphBasicBlock.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNGetFlowGraphBasicBlock(
node: ctypes.POINTER(BNFlowGraphNode)
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetFlowGraphBasicBlock(node)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphHeight
_BNGetFlowGraphHeight = core.BNGetFlowGraphHeight
_BNGetFlowGraphHeight.restype = ctypes.c_int
_BNGetFlowGraphHeight.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNGetFlowGraphHeight(
graph: ctypes.POINTER(BNFlowGraph)
) -> int:
return _BNGetFlowGraphHeight(graph)
# -------------------------------------------------------
# _BNGetFlowGraphHighLevelILFunction
_BNGetFlowGraphHighLevelILFunction = core.BNGetFlowGraphHighLevelILFunction
_BNGetFlowGraphHighLevelILFunction.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetFlowGraphHighLevelILFunction.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNGetFlowGraphHighLevelILFunction(
graph: ctypes.POINTER(BNFlowGraph)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNGetFlowGraphHighLevelILFunction(graph)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphLowLevelILFunction
_BNGetFlowGraphLowLevelILFunction = core.BNGetFlowGraphLowLevelILFunction
_BNGetFlowGraphLowLevelILFunction.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFlowGraphLowLevelILFunction.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNGetFlowGraphLowLevelILFunction(
graph: ctypes.POINTER(BNFlowGraph)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetFlowGraphLowLevelILFunction(graph)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphMediumLevelILFunction
_BNGetFlowGraphMediumLevelILFunction = core.BNGetFlowGraphMediumLevelILFunction
_BNGetFlowGraphMediumLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFlowGraphMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNGetFlowGraphMediumLevelILFunction(
graph: ctypes.POINTER(BNFlowGraph)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetFlowGraphMediumLevelILFunction(graph)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphNode
_BNGetFlowGraphNode = core.BNGetFlowGraphNode
_BNGetFlowGraphNode.restype = ctypes.POINTER(BNFlowGraphNode)
_BNGetFlowGraphNode.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetFlowGraphNode(
graph: ctypes.POINTER(BNFlowGraph),
i: int
) -> Optional[ctypes.POINTER(BNFlowGraphNode)]:
result = _BNGetFlowGraphNode(graph, i)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphNodeHeight
_BNGetFlowGraphNodeHeight = core.BNGetFlowGraphNodeHeight
_BNGetFlowGraphNodeHeight.restype = ctypes.c_int
_BNGetFlowGraphNodeHeight.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodeHeight(
node: ctypes.POINTER(BNFlowGraphNode)
) -> int:
return _BNGetFlowGraphNodeHeight(node)
# -------------------------------------------------------
# _BNGetFlowGraphNodeHighlight
_BNGetFlowGraphNodeHighlight = core.BNGetFlowGraphNodeHighlight
_BNGetFlowGraphNodeHighlight.restype = BNHighlightColor
_BNGetFlowGraphNodeHighlight.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodeHighlight(
node: ctypes.POINTER(BNFlowGraphNode)
) -> BNHighlightColor:
return _BNGetFlowGraphNodeHighlight(node)
# -------------------------------------------------------
# _BNGetFlowGraphNodeIncomingEdges
_BNGetFlowGraphNodeIncomingEdges = core.BNGetFlowGraphNodeIncomingEdges
_BNGetFlowGraphNodeIncomingEdges.restype = ctypes.POINTER(BNFlowGraphEdge)
_BNGetFlowGraphNodeIncomingEdges.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodeIncomingEdges(
node: ctypes.POINTER(BNFlowGraphNode),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNFlowGraphEdge)]:
result = _BNGetFlowGraphNodeIncomingEdges(node, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphNodeLines
_BNGetFlowGraphNodeLines = core.BNGetFlowGraphNodeLines
_BNGetFlowGraphNodeLines.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetFlowGraphNodeLines.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodeLines(
node: ctypes.POINTER(BNFlowGraphNode),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
result = _BNGetFlowGraphNodeLines(node, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphNodeOutgoingEdges
_BNGetFlowGraphNodeOutgoingEdges = core.BNGetFlowGraphNodeOutgoingEdges
_BNGetFlowGraphNodeOutgoingEdges.restype = ctypes.POINTER(BNFlowGraphEdge)
_BNGetFlowGraphNodeOutgoingEdges.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodeOutgoingEdges(
node: ctypes.POINTER(BNFlowGraphNode),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNFlowGraphEdge)]:
result = _BNGetFlowGraphNodeOutgoingEdges(node, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphNodeOwner
_BNGetFlowGraphNodeOwner = core.BNGetFlowGraphNodeOwner
_BNGetFlowGraphNodeOwner.restype = ctypes.POINTER(BNFlowGraph)
_BNGetFlowGraphNodeOwner.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodeOwner(
node: ctypes.POINTER(BNFlowGraphNode)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNGetFlowGraphNodeOwner(node)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphNodeWidth
_BNGetFlowGraphNodeWidth = core.BNGetFlowGraphNodeWidth
_BNGetFlowGraphNodeWidth.restype = ctypes.c_int
_BNGetFlowGraphNodeWidth.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodeWidth(
node: ctypes.POINTER(BNFlowGraphNode)
) -> int:
return _BNGetFlowGraphNodeWidth(node)
# -------------------------------------------------------
# _BNGetFlowGraphNodeX
_BNGetFlowGraphNodeX = core.BNGetFlowGraphNodeX
_BNGetFlowGraphNodeX.restype = ctypes.c_int
_BNGetFlowGraphNodeX.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodeX(
node: ctypes.POINTER(BNFlowGraphNode)
) -> int:
return _BNGetFlowGraphNodeX(node)
# -------------------------------------------------------
# _BNGetFlowGraphNodeY
_BNGetFlowGraphNodeY = core.BNGetFlowGraphNodeY
_BNGetFlowGraphNodeY.restype = ctypes.c_int
_BNGetFlowGraphNodeY.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodeY(
node: ctypes.POINTER(BNFlowGraphNode)
) -> int:
return _BNGetFlowGraphNodeY(node)
# -------------------------------------------------------
# _BNGetFlowGraphNodes
_BNGetFlowGraphNodes = core.BNGetFlowGraphNodes
_BNGetFlowGraphNodes.restype = ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode))
_BNGetFlowGraphNodes.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodes(
graph: ctypes.POINTER(BNFlowGraph),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode))]:
result = _BNGetFlowGraphNodes(graph, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphNodesInRegion
_BNGetFlowGraphNodesInRegion = core.BNGetFlowGraphNodesInRegion
_BNGetFlowGraphNodesInRegion.restype = ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode))
_BNGetFlowGraphNodesInRegion.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.c_int,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFlowGraphNodesInRegion(
graph: ctypes.POINTER(BNFlowGraph),
left: int,
top: int,
right: int,
bottom: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNFlowGraphNode))]:
result = _BNGetFlowGraphNodesInRegion(graph, left, top, right, bottom, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFlowGraphWidth
_BNGetFlowGraphWidth = core.BNGetFlowGraphWidth
_BNGetFlowGraphWidth.restype = ctypes.c_int
_BNGetFlowGraphWidth.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNGetFlowGraphWidth(
graph: ctypes.POINTER(BNFlowGraph)
) -> int:
return _BNGetFlowGraphWidth(graph)
# -------------------------------------------------------
# _BNGetFormInput
_BNGetFormInput = core.BNGetFormInput
_BNGetFormInput.restype = ctypes.c_bool
_BNGetFormInput.argtypes = [
ctypes.POINTER(BNFormInputField),
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetFormInput(
fields: ctypes.POINTER(BNFormInputField),
count: int,
title: Optional[str]
) -> bool:
return _BNGetFormInput(fields, count, cstr(title))
# -------------------------------------------------------
# _BNGetFullInfoUpdateChannels
_BNGetFullInfoUpdateChannels = core.BNGetFullInfoUpdateChannels
_BNGetFullInfoUpdateChannels.restype = ctypes.POINTER(BNUpdateChannelFullInfo)
_BNGetFullInfoUpdateChannels.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNGetFullInfoUpdateChannels(
count: ctypes.POINTER(ctypes.c_ulonglong),
errors: ctypes.POINTER(ctypes.c_char_p)
) -> Optional[ctypes.POINTER(BNUpdateChannelFullInfo)]:
result = _BNGetFullInfoUpdateChannels(count, errors)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFullWidthArchitectureRegisters
_BNGetFullWidthArchitectureRegisters = core.BNGetFullWidthArchitectureRegisters
_BNGetFullWidthArchitectureRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetFullWidthArchitectureRegisters.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFullWidthArchitectureRegisters(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetFullWidthArchitectureRegisters(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionAddressRanges
_BNGetFunctionAddressRanges = core.BNGetFunctionAddressRanges
_BNGetFunctionAddressRanges.restype = ctypes.POINTER(BNAddressRange)
_BNGetFunctionAddressRanges.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionAddressRanges(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNAddressRange)]:
result = _BNGetFunctionAddressRanges(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionAllTagReferences
_BNGetFunctionAllTagReferences = core.BNGetFunctionAllTagReferences
_BNGetFunctionAllTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetFunctionAllTagReferences.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionAllTagReferences(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetFunctionAllTagReferences(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionAnalysisPerformanceInfo
_BNGetFunctionAnalysisPerformanceInfo = core.BNGetFunctionAnalysisPerformanceInfo
_BNGetFunctionAnalysisPerformanceInfo.restype = ctypes.POINTER(BNPerformanceInfo)
_BNGetFunctionAnalysisPerformanceInfo.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionAnalysisPerformanceInfo(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPerformanceInfo)]:
result = _BNGetFunctionAnalysisPerformanceInfo(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionAnalysisSkipOverride
_BNGetFunctionAnalysisSkipOverride = core.BNGetFunctionAnalysisSkipOverride
_BNGetFunctionAnalysisSkipOverride.restype = FunctionAnalysisSkipOverrideEnum
_BNGetFunctionAnalysisSkipOverride.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionAnalysisSkipOverride(
func: ctypes.POINTER(BNFunction)
) -> FunctionAnalysisSkipOverride:
return _BNGetFunctionAnalysisSkipOverride(func)
# -------------------------------------------------------
# _BNGetFunctionArchitecture
_BNGetFunctionArchitecture = core.BNGetFunctionArchitecture
_BNGetFunctionArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetFunctionArchitecture.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionArchitecture(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetFunctionArchitecture(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionBasicBlockAtAddress
_BNGetFunctionBasicBlockAtAddress = core.BNGetFunctionBasicBlockAtAddress
_BNGetFunctionBasicBlockAtAddress.restype = ctypes.POINTER(BNBasicBlock)
_BNGetFunctionBasicBlockAtAddress.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetFunctionBasicBlockAtAddress(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetFunctionBasicBlockAtAddress(func, arch, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionBasicBlockList
_BNGetFunctionBasicBlockList = core.BNGetFunctionBasicBlockList
_BNGetFunctionBasicBlockList.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetFunctionBasicBlockList.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionBasicBlockList(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetFunctionBasicBlockList(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionBlockAnnotations
_BNGetFunctionBlockAnnotations = core.BNGetFunctionBlockAnnotations
_BNGetFunctionBlockAnnotations.restype = ctypes.POINTER(BNInstructionTextLine)
_BNGetFunctionBlockAnnotations.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionBlockAnnotations(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextLine)]:
result = _BNGetFunctionBlockAnnotations(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionCallSites
_BNGetFunctionCallSites = core.BNGetFunctionCallSites
_BNGetFunctionCallSites.restype = ctypes.POINTER(BNReferenceSource)
_BNGetFunctionCallSites.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionCallSites(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNReferenceSource)]:
result = _BNGetFunctionCallSites(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionCallingConvention
_BNGetFunctionCallingConvention = core.BNGetFunctionCallingConvention
_BNGetFunctionCallingConvention.restype = BNCallingConventionWithConfidence
_BNGetFunctionCallingConvention.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionCallingConvention(
func: ctypes.POINTER(BNFunction)
) -> BNCallingConventionWithConfidence:
return _BNGetFunctionCallingConvention(func)
# -------------------------------------------------------
# _BNGetFunctionClobberedRegisters
_BNGetFunctionClobberedRegisters = core.BNGetFunctionClobberedRegisters
_BNGetFunctionClobberedRegisters.restype = BNRegisterSetWithConfidence
_BNGetFunctionClobberedRegisters.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionClobberedRegisters(
func: ctypes.POINTER(BNFunction)
) -> BNRegisterSetWithConfidence:
return _BNGetFunctionClobberedRegisters(func)
# -------------------------------------------------------
# _BNGetFunctionComment
_BNGetFunctionComment = core.BNGetFunctionComment
_BNGetFunctionComment.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetFunctionComment.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionComment(
func: ctypes.POINTER(BNFunction)
) -> Optional[Optional[str]]:
result = _BNGetFunctionComment(func)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetFunctionData
_BNGetFunctionData = core.BNGetFunctionData
_BNGetFunctionData.restype = ctypes.POINTER(BNBinaryView)
_BNGetFunctionData.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionData(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNGetFunctionData(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionForFlowGraph
_BNGetFunctionForFlowGraph = core.BNGetFunctionForFlowGraph
_BNGetFunctionForFlowGraph.restype = ctypes.POINTER(BNFunction)
_BNGetFunctionForFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNGetFunctionForFlowGraph(
graph: ctypes.POINTER(BNFlowGraph)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetFunctionForFlowGraph(graph)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionGlobalPointerValue
_BNGetFunctionGlobalPointerValue = core.BNGetFunctionGlobalPointerValue
_BNGetFunctionGlobalPointerValue.restype = BNRegisterValueWithConfidence
_BNGetFunctionGlobalPointerValue.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionGlobalPointerValue(
func: ctypes.POINTER(BNFunction)
) -> BNRegisterValueWithConfidence:
return _BNGetFunctionGlobalPointerValue(func)
# -------------------------------------------------------
# _BNGetFunctionHighLevelIL
_BNGetFunctionHighLevelIL = core.BNGetFunctionHighLevelIL
_BNGetFunctionHighLevelIL.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetFunctionHighLevelIL.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionHighLevelIL(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNGetFunctionHighLevelIL(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionHighLevelILIfAvailable
_BNGetFunctionHighLevelILIfAvailable = core.BNGetFunctionHighLevelILIfAvailable
_BNGetFunctionHighLevelILIfAvailable.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetFunctionHighLevelILIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionHighLevelILIfAvailable(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNGetFunctionHighLevelILIfAvailable(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionHighestAddress
_BNGetFunctionHighestAddress = core.BNGetFunctionHighestAddress
_BNGetFunctionHighestAddress.restype = ctypes.c_ulonglong
_BNGetFunctionHighestAddress.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionHighestAddress(
func: ctypes.POINTER(BNFunction)
) -> int:
return _BNGetFunctionHighestAddress(func)
# -------------------------------------------------------
# _BNGetFunctionLanguageRepresentation
_BNGetFunctionLanguageRepresentation = core.BNGetFunctionLanguageRepresentation
_BNGetFunctionLanguageRepresentation.restype = ctypes.POINTER(BNLanguageRepresentationFunction)
_BNGetFunctionLanguageRepresentation.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionLanguageRepresentation(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNLanguageRepresentationFunction)]:
result = _BNGetFunctionLanguageRepresentation(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionLanguageRepresentationIfAvailable
_BNGetFunctionLanguageRepresentationIfAvailable = core.BNGetFunctionLanguageRepresentationIfAvailable
_BNGetFunctionLanguageRepresentationIfAvailable.restype = ctypes.POINTER(BNLanguageRepresentationFunction)
_BNGetFunctionLanguageRepresentationIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionLanguageRepresentationIfAvailable(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNLanguageRepresentationFunction)]:
result = _BNGetFunctionLanguageRepresentationIfAvailable(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionLiftedIL
_BNGetFunctionLiftedIL = core.BNGetFunctionLiftedIL
_BNGetFunctionLiftedIL.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFunctionLiftedIL.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionLiftedIL(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetFunctionLiftedIL(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionLiftedILIfAvailable
_BNGetFunctionLiftedILIfAvailable = core.BNGetFunctionLiftedILIfAvailable
_BNGetFunctionLiftedILIfAvailable.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFunctionLiftedILIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionLiftedILIfAvailable(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetFunctionLiftedILIfAvailable(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionLowLevelIL
_BNGetFunctionLowLevelIL = core.BNGetFunctionLowLevelIL
_BNGetFunctionLowLevelIL.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFunctionLowLevelIL.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionLowLevelIL(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetFunctionLowLevelIL(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionLowLevelILIfAvailable
_BNGetFunctionLowLevelILIfAvailable = core.BNGetFunctionLowLevelILIfAvailable
_BNGetFunctionLowLevelILIfAvailable.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetFunctionLowLevelILIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionLowLevelILIfAvailable(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetFunctionLowLevelILIfAvailable(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionLowestAddress
_BNGetFunctionLowestAddress = core.BNGetFunctionLowestAddress
_BNGetFunctionLowestAddress.restype = ctypes.c_ulonglong
_BNGetFunctionLowestAddress.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionLowestAddress(
func: ctypes.POINTER(BNFunction)
) -> int:
return _BNGetFunctionLowestAddress(func)
# -------------------------------------------------------
# _BNGetFunctionMappedMediumLevelIL
_BNGetFunctionMappedMediumLevelIL = core.BNGetFunctionMappedMediumLevelIL
_BNGetFunctionMappedMediumLevelIL.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFunctionMappedMediumLevelIL.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionMappedMediumLevelIL(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetFunctionMappedMediumLevelIL(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionMappedMediumLevelILIfAvailable
_BNGetFunctionMappedMediumLevelILIfAvailable = core.BNGetFunctionMappedMediumLevelILIfAvailable
_BNGetFunctionMappedMediumLevelILIfAvailable.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFunctionMappedMediumLevelILIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionMappedMediumLevelILIfAvailable(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetFunctionMappedMediumLevelILIfAvailable(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionMediumLevelIL
_BNGetFunctionMediumLevelIL = core.BNGetFunctionMediumLevelIL
_BNGetFunctionMediumLevelIL.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFunctionMediumLevelIL.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionMediumLevelIL(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetFunctionMediumLevelIL(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionMediumLevelILIfAvailable
_BNGetFunctionMediumLevelILIfAvailable = core.BNGetFunctionMediumLevelILIfAvailable
_BNGetFunctionMediumLevelILIfAvailable.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetFunctionMediumLevelILIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionMediumLevelILIfAvailable(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetFunctionMediumLevelILIfAvailable(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionParameterVariables
_BNGetFunctionParameterVariables = core.BNGetFunctionParameterVariables
_BNGetFunctionParameterVariables.restype = BNParameterVariablesWithConfidence
_BNGetFunctionParameterVariables.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionParameterVariables(
func: ctypes.POINTER(BNFunction)
) -> BNParameterVariablesWithConfidence:
return _BNGetFunctionParameterVariables(func)
# -------------------------------------------------------
# _BNGetFunctionParentComponents
_BNGetFunctionParentComponents = core.BNGetFunctionParentComponents
_BNGetFunctionParentComponents.restype = ctypes.POINTER(ctypes.POINTER(BNComponent))
_BNGetFunctionParentComponents.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionParentComponents(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNComponent))]:
result = _BNGetFunctionParentComponents(view, func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionPlatform
_BNGetFunctionPlatform = core.BNGetFunctionPlatform
_BNGetFunctionPlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetFunctionPlatform.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionPlatform(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNGetFunctionPlatform(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionRegisterStackAdjustments
_BNGetFunctionRegisterStackAdjustments = core.BNGetFunctionRegisterStackAdjustments
_BNGetFunctionRegisterStackAdjustments.restype = ctypes.POINTER(BNRegisterStackAdjustment)
_BNGetFunctionRegisterStackAdjustments.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionRegisterStackAdjustments(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNRegisterStackAdjustment)]:
result = _BNGetFunctionRegisterStackAdjustments(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionRegisterValueAtExit
_BNGetFunctionRegisterValueAtExit = core.BNGetFunctionRegisterValueAtExit
_BNGetFunctionRegisterValueAtExit.restype = BNRegisterValueWithConfidence
_BNGetFunctionRegisterValueAtExit.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetFunctionRegisterValueAtExit(
func: ctypes.POINTER(BNFunction),
reg: int
) -> BNRegisterValueWithConfidence:
return _BNGetFunctionRegisterValueAtExit(func, reg)
# -------------------------------------------------------
# _BNGetFunctionReturnRegisters
_BNGetFunctionReturnRegisters = core.BNGetFunctionReturnRegisters
_BNGetFunctionReturnRegisters.restype = BNRegisterSetWithConfidence
_BNGetFunctionReturnRegisters.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionReturnRegisters(
func: ctypes.POINTER(BNFunction)
) -> BNRegisterSetWithConfidence:
return _BNGetFunctionReturnRegisters(func)
# -------------------------------------------------------
# _BNGetFunctionReturnType
_BNGetFunctionReturnType = core.BNGetFunctionReturnType
_BNGetFunctionReturnType.restype = BNTypeWithConfidence
_BNGetFunctionReturnType.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionReturnType(
func: ctypes.POINTER(BNFunction)
) -> BNTypeWithConfidence:
return _BNGetFunctionReturnType(func)
# -------------------------------------------------------
# _BNGetFunctionStackAdjustment
_BNGetFunctionStackAdjustment = core.BNGetFunctionStackAdjustment
_BNGetFunctionStackAdjustment.restype = BNOffsetWithConfidence
_BNGetFunctionStackAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionStackAdjustment(
func: ctypes.POINTER(BNFunction)
) -> BNOffsetWithConfidence:
return _BNGetFunctionStackAdjustment(func)
# -------------------------------------------------------
# _BNGetFunctionStart
_BNGetFunctionStart = core.BNGetFunctionStart
_BNGetFunctionStart.restype = ctypes.c_ulonglong
_BNGetFunctionStart.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionStart(
func: ctypes.POINTER(BNFunction)
) -> int:
return _BNGetFunctionStart(func)
# -------------------------------------------------------
# _BNGetFunctionSymbol
_BNGetFunctionSymbol = core.BNGetFunctionSymbol
_BNGetFunctionSymbol.restype = ctypes.POINTER(BNSymbol)
_BNGetFunctionSymbol.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionSymbol(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNSymbol)]:
result = _BNGetFunctionSymbol(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionTagReferences
_BNGetFunctionTagReferences = core.BNGetFunctionTagReferences
_BNGetFunctionTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetFunctionTagReferences.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionTagReferences(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetFunctionTagReferences(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionTagReferencesOfType
_BNGetFunctionTagReferencesOfType = core.BNGetFunctionTagReferencesOfType
_BNGetFunctionTagReferencesOfType.restype = ctypes.POINTER(BNTagReference)
_BNGetFunctionTagReferencesOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionTagReferencesOfType(
func: ctypes.POINTER(BNFunction),
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetFunctionTagReferencesOfType(func, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionTags
_BNGetFunctionTags = core.BNGetFunctionTags
_BNGetFunctionTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetFunctionTags.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionTags(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetFunctionTags(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionTagsOfType
_BNGetFunctionTagsOfType = core.BNGetFunctionTagsOfType
_BNGetFunctionTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetFunctionTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionTagsOfType(
func: ctypes.POINTER(BNFunction),
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetFunctionTagsOfType(func, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionType
_BNGetFunctionType = core.BNGetFunctionType
_BNGetFunctionType.restype = ctypes.POINTER(BNType)
_BNGetFunctionType.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetFunctionType(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetFunctionType(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionTypeTokens
_BNGetFunctionTypeTokens = core.BNGetFunctionTypeTokens
_BNGetFunctionTypeTokens.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetFunctionTypeTokens.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNDisassemblySettings),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionTypeTokens(
func: ctypes.POINTER(BNFunction),
settings: ctypes.POINTER(BNDisassemblySettings),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
result = _BNGetFunctionTypeTokens(func, settings, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetFunctionVariableDeadStoreElimination
_BNGetFunctionVariableDeadStoreElimination = core.BNGetFunctionVariableDeadStoreElimination
_BNGetFunctionVariableDeadStoreElimination.restype = DeadStoreEliminationEnum
_BNGetFunctionVariableDeadStoreElimination.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNGetFunctionVariableDeadStoreElimination(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable)
) -> DeadStoreElimination:
return _BNGetFunctionVariableDeadStoreElimination(func, var)
# -------------------------------------------------------
# _BNGetFunctionVariables
_BNGetFunctionVariables = core.BNGetFunctionVariables
_BNGetFunctionVariables.restype = ctypes.POINTER(BNVariableNameAndType)
_BNGetFunctionVariables.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetFunctionVariables(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableNameAndType)]:
result = _BNGetFunctionVariables(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetGlobalCommentForAddress
_BNGetGlobalCommentForAddress = core.BNGetGlobalCommentForAddress
_BNGetGlobalCommentForAddress.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetGlobalCommentForAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetGlobalCommentForAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> Optional[Optional[str]]:
result = _BNGetGlobalCommentForAddress(view, addr)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetGlobalCommentedAddresses
_BNGetGlobalCommentedAddresses = core.BNGetGlobalCommentedAddresses
_BNGetGlobalCommentedAddresses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetGlobalCommentedAddresses.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetGlobalCommentedAddresses(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetGlobalCommentedAddresses(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetGlobalPointerRegister
_BNGetGlobalPointerRegister = core.BNGetGlobalPointerRegister
_BNGetGlobalPointerRegister.restype = ctypes.c_uint
_BNGetGlobalPointerRegister.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNGetGlobalPointerRegister(
cc: ctypes.POINTER(BNCallingConvention)
) -> int:
return _BNGetGlobalPointerRegister(cc)
# -------------------------------------------------------
# _BNGetGlobalPointerValue
_BNGetGlobalPointerValue = core.BNGetGlobalPointerValue
_BNGetGlobalPointerValue.restype = BNRegisterValueWithConfidence
_BNGetGlobalPointerValue.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetGlobalPointerValue(
view: ctypes.POINTER(BNBinaryView)
) -> BNRegisterValueWithConfidence:
return _BNGetGlobalPointerValue(view)
# -------------------------------------------------------
# _BNGetGotoLabelName
_BNGetGotoLabelName = core.BNGetGotoLabelName
_BNGetGotoLabelName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetGotoLabelName.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetGotoLabelName(
func: ctypes.POINTER(BNFunction),
labelId: int
) -> Optional[Optional[str]]:
result = _BNGetGotoLabelName(func, labelId)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetGraphForFlowGraphLayoutRequest
_BNGetGraphForFlowGraphLayoutRequest = core.BNGetGraphForFlowGraphLayoutRequest
_BNGetGraphForFlowGraphLayoutRequest.restype = ctypes.POINTER(BNFlowGraph)
_BNGetGraphForFlowGraphLayoutRequest.argtypes = [
ctypes.POINTER(BNFlowGraphLayoutRequest),
]
# noinspection PyPep8Naming
def BNGetGraphForFlowGraphLayoutRequest(
layout: ctypes.POINTER(BNFlowGraphLayoutRequest)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNGetGraphForFlowGraphLayoutRequest(layout)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighIntegerReturnValueRegister
_BNGetHighIntegerReturnValueRegister = core.BNGetHighIntegerReturnValueRegister
_BNGetHighIntegerReturnValueRegister.restype = ctypes.c_uint
_BNGetHighIntegerReturnValueRegister.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNGetHighIntegerReturnValueRegister(
cc: ctypes.POINTER(BNCallingConvention)
) -> int:
return _BNGetHighIntegerReturnValueRegister(cc)
# -------------------------------------------------------
# _BNGetHighLevelILAliasedVariables
_BNGetHighLevelILAliasedVariables = core.BNGetHighLevelILAliasedVariables
_BNGetHighLevelILAliasedVariables.restype = ctypes.POINTER(BNVariable)
_BNGetHighLevelILAliasedVariables.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILAliasedVariables(
func: ctypes.POINTER(BNHighLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariable)]:
result = _BNGetHighLevelILAliasedVariables(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILBasicBlockForInstruction
_BNGetHighLevelILBasicBlockForInstruction = core.BNGetHighLevelILBasicBlockForInstruction
_BNGetHighLevelILBasicBlockForInstruction.restype = ctypes.POINTER(BNBasicBlock)
_BNGetHighLevelILBasicBlockForInstruction.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILBasicBlockForInstruction(
func: ctypes.POINTER(BNHighLevelILFunction),
i: int
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetHighLevelILBasicBlockForInstruction(func, i)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILBasicBlockList
_BNGetHighLevelILBasicBlockList = core.BNGetHighLevelILBasicBlockList
_BNGetHighLevelILBasicBlockList.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetHighLevelILBasicBlockList.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILBasicBlockList(
func: ctypes.POINTER(BNHighLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetHighLevelILBasicBlockList(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILByIndex
_BNGetHighLevelILByIndex = core.BNGetHighLevelILByIndex
_BNGetHighLevelILByIndex.restype = BNHighLevelILInstruction
_BNGetHighLevelILByIndex.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNGetHighLevelILByIndex(
func: ctypes.POINTER(BNHighLevelILFunction),
i: int,
asFullAst: bool
) -> BNHighLevelILInstruction:
return _BNGetHighLevelILByIndex(func, i, asFullAst)
# -------------------------------------------------------
# _BNGetHighLevelILExprCount
_BNGetHighLevelILExprCount = core.BNGetHighLevelILExprCount
_BNGetHighLevelILExprCount.restype = ctypes.c_ulonglong
_BNGetHighLevelILExprCount.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetHighLevelILExprCount(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> int:
return _BNGetHighLevelILExprCount(func)
# -------------------------------------------------------
# _BNGetHighLevelILExprIndex
_BNGetHighLevelILExprIndex = core.BNGetHighLevelILExprIndex
_BNGetHighLevelILExprIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILExprIndex.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILExprIndex(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int
) -> int:
return _BNGetHighLevelILExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetHighLevelILExprIndexForLabel
_BNGetHighLevelILExprIndexForLabel = core.BNGetHighLevelILExprIndexForLabel
_BNGetHighLevelILExprIndexForLabel.restype = ctypes.c_ulonglong
_BNGetHighLevelILExprIndexForLabel.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILExprIndexForLabel(
func: ctypes.POINTER(BNHighLevelILFunction),
label: int
) -> int:
return _BNGetHighLevelILExprIndexForLabel(func, label)
# -------------------------------------------------------
# _BNGetHighLevelILExprIndexes
_BNGetHighLevelILExprIndexes = core.BNGetHighLevelILExprIndexes
_BNGetHighLevelILExprIndexes.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILExprIndexes.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILExprIndexes(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetHighLevelILExprIndexes(func, expr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILExprText
_BNGetHighLevelILExprText = core.BNGetHighLevelILExprText
_BNGetHighLevelILExprText.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetHighLevelILExprText.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_bool,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNGetHighLevelILExprText(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int,
asFullAst: bool,
count: ctypes.POINTER(ctypes.c_ulonglong),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
result = _BNGetHighLevelILExprText(func, expr, asFullAst, count, settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILExprType
_BNGetHighLevelILExprType = core.BNGetHighLevelILExprType
_BNGetHighLevelILExprType.restype = BNTypeWithConfidence
_BNGetHighLevelILExprType.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILExprType(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int
) -> BNTypeWithConfidence:
return _BNGetHighLevelILExprType(func, expr)
# -------------------------------------------------------
# _BNGetHighLevelILForMediumLevelIL
_BNGetHighLevelILForMediumLevelIL = core.BNGetHighLevelILForMediumLevelIL
_BNGetHighLevelILForMediumLevelIL.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetHighLevelILForMediumLevelIL.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetHighLevelILForMediumLevelIL(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNGetHighLevelILForMediumLevelIL(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILIndexForInstruction
_BNGetHighLevelILIndexForInstruction = core.BNGetHighLevelILIndexForInstruction
_BNGetHighLevelILIndexForInstruction.restype = ctypes.c_ulonglong
_BNGetHighLevelILIndexForInstruction.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILIndexForInstruction(
func: ctypes.POINTER(BNHighLevelILFunction),
i: int
) -> int:
return _BNGetHighLevelILIndexForInstruction(func, i)
# -------------------------------------------------------
# _BNGetHighLevelILInstructionCount
_BNGetHighLevelILInstructionCount = core.BNGetHighLevelILInstructionCount
_BNGetHighLevelILInstructionCount.restype = ctypes.c_ulonglong
_BNGetHighLevelILInstructionCount.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetHighLevelILInstructionCount(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> int:
return _BNGetHighLevelILInstructionCount(func)
# -------------------------------------------------------
# _BNGetHighLevelILInstructionForExpr
_BNGetHighLevelILInstructionForExpr = core.BNGetHighLevelILInstructionForExpr
_BNGetHighLevelILInstructionForExpr.restype = ctypes.c_ulonglong
_BNGetHighLevelILInstructionForExpr.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILInstructionForExpr(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int
) -> int:
return _BNGetHighLevelILInstructionForExpr(func, expr)
# -------------------------------------------------------
# _BNGetHighLevelILInstructionIndex
_BNGetHighLevelILInstructionIndex = core.BNGetHighLevelILInstructionIndex
_BNGetHighLevelILInstructionIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILInstructionIndex.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILInstructionIndex(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int
) -> int:
return _BNGetHighLevelILInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetHighLevelILNonSSAExprIndex
_BNGetHighLevelILNonSSAExprIndex = core.BNGetHighLevelILNonSSAExprIndex
_BNGetHighLevelILNonSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILNonSSAExprIndex.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILNonSSAExprIndex(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int
) -> int:
return _BNGetHighLevelILNonSSAExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetHighLevelILNonSSAForm
_BNGetHighLevelILNonSSAForm = core.BNGetHighLevelILNonSSAForm
_BNGetHighLevelILNonSSAForm.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetHighLevelILNonSSAForm.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetHighLevelILNonSSAForm(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNGetHighLevelILNonSSAForm(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILNonSSAInstructionIndex
_BNGetHighLevelILNonSSAInstructionIndex = core.BNGetHighLevelILNonSSAInstructionIndex
_BNGetHighLevelILNonSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILNonSSAInstructionIndex.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILNonSSAInstructionIndex(
func: ctypes.POINTER(BNHighLevelILFunction),
instr: int
) -> int:
return _BNGetHighLevelILNonSSAInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetHighLevelILOwnerFunction
_BNGetHighLevelILOwnerFunction = core.BNGetHighLevelILOwnerFunction
_BNGetHighLevelILOwnerFunction.restype = ctypes.POINTER(BNFunction)
_BNGetHighLevelILOwnerFunction.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetHighLevelILOwnerFunction(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetHighLevelILOwnerFunction(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILRootExpr
_BNGetHighLevelILRootExpr = core.BNGetHighLevelILRootExpr
_BNGetHighLevelILRootExpr.restype = ctypes.c_ulonglong
_BNGetHighLevelILRootExpr.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetHighLevelILRootExpr(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> int:
return _BNGetHighLevelILRootExpr(func)
# -------------------------------------------------------
# _BNGetHighLevelILSSAExprIndex
_BNGetHighLevelILSSAExprIndex = core.BNGetHighLevelILSSAExprIndex
_BNGetHighLevelILSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAExprIndex.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILSSAExprIndex(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int
) -> int:
return _BNGetHighLevelILSSAExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetHighLevelILSSAForm
_BNGetHighLevelILSSAForm = core.BNGetHighLevelILSSAForm
_BNGetHighLevelILSSAForm.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNGetHighLevelILSSAForm.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetHighLevelILSSAForm(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNGetHighLevelILSSAForm(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILSSAInstructionIndex
_BNGetHighLevelILSSAInstructionIndex = core.BNGetHighLevelILSSAInstructionIndex
_BNGetHighLevelILSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAInstructionIndex.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILSSAInstructionIndex(
func: ctypes.POINTER(BNHighLevelILFunction),
instr: int
) -> int:
return _BNGetHighLevelILSSAInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetHighLevelILSSAMemoryDefinition
_BNGetHighLevelILSSAMemoryDefinition = core.BNGetHighLevelILSSAMemoryDefinition
_BNGetHighLevelILSSAMemoryDefinition.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAMemoryDefinition.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILSSAMemoryDefinition(
func: ctypes.POINTER(BNHighLevelILFunction),
version: int
) -> int:
return _BNGetHighLevelILSSAMemoryDefinition(func, version)
# -------------------------------------------------------
# _BNGetHighLevelILSSAMemoryUses
_BNGetHighLevelILSSAMemoryUses = core.BNGetHighLevelILSSAMemoryUses
_BNGetHighLevelILSSAMemoryUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILSSAMemoryUses.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILSSAMemoryUses(
func: ctypes.POINTER(BNHighLevelILFunction),
version: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetHighLevelILSSAMemoryUses(func, version, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILSSAMemoryVersionAtILInstruction
_BNGetHighLevelILSSAMemoryVersionAtILInstruction = core.BNGetHighLevelILSSAMemoryVersionAtILInstruction
_BNGetHighLevelILSSAMemoryVersionAtILInstruction.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAMemoryVersionAtILInstruction.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILSSAMemoryVersionAtILInstruction(
func: ctypes.POINTER(BNHighLevelILFunction),
instr: int
) -> int:
return _BNGetHighLevelILSSAMemoryVersionAtILInstruction(func, instr)
# -------------------------------------------------------
# _BNGetHighLevelILSSAVarDefinition
_BNGetHighLevelILSSAVarDefinition = core.BNGetHighLevelILSSAVarDefinition
_BNGetHighLevelILSSAVarDefinition.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAVarDefinition.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILSSAVarDefinition(
func: ctypes.POINTER(BNHighLevelILFunction),
var: ctypes.POINTER(BNVariable),
version: int
) -> int:
return _BNGetHighLevelILSSAVarDefinition(func, var, version)
# -------------------------------------------------------
# _BNGetHighLevelILSSAVarUses
_BNGetHighLevelILSSAVarUses = core.BNGetHighLevelILSSAVarUses
_BNGetHighLevelILSSAVarUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILSSAVarUses.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILSSAVarUses(
func: ctypes.POINTER(BNHighLevelILFunction),
var: ctypes.POINTER(BNVariable),
version: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetHighLevelILSSAVarUses(func, var, version, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILSSAVarVersionAtILInstruction
_BNGetHighLevelILSSAVarVersionAtILInstruction = core.BNGetHighLevelILSSAVarVersionAtILInstruction
_BNGetHighLevelILSSAVarVersionAtILInstruction.restype = ctypes.c_ulonglong
_BNGetHighLevelILSSAVarVersionAtILInstruction.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetHighLevelILSSAVarVersionAtILInstruction(
func: ctypes.POINTER(BNHighLevelILFunction),
var: ctypes.POINTER(BNVariable),
instr: int
) -> int:
return _BNGetHighLevelILSSAVarVersionAtILInstruction(func, var, instr)
# -------------------------------------------------------
# _BNGetHighLevelILUsesForLabel
_BNGetHighLevelILUsesForLabel = core.BNGetHighLevelILUsesForLabel
_BNGetHighLevelILUsesForLabel.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILUsesForLabel.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILUsesForLabel(
func: ctypes.POINTER(BNHighLevelILFunction),
label: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetHighLevelILUsesForLabel(func, label, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariableDefinitions
_BNGetHighLevelILVariableDefinitions = core.BNGetHighLevelILVariableDefinitions
_BNGetHighLevelILVariableDefinitions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILVariableDefinitions.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariableDefinitions(
func: ctypes.POINTER(BNHighLevelILFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetHighLevelILVariableDefinitions(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariableReferences
_BNGetHighLevelILVariableReferences = core.BNGetHighLevelILVariableReferences
_BNGetHighLevelILVariableReferences.restype = ctypes.POINTER(BNILReferenceSource)
_BNGetHighLevelILVariableReferences.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferences(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNILReferenceSource)]:
result = _BNGetHighLevelILVariableReferences(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesFrom
_BNGetHighLevelILVariableReferencesFrom = core.BNGetHighLevelILVariableReferencesFrom
_BNGetHighLevelILVariableReferencesFrom.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetHighLevelILVariableReferencesFrom.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesFrom(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
address: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
result = _BNGetHighLevelILVariableReferencesFrom(func, arch, address, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesFromIfAvailable
_BNGetHighLevelILVariableReferencesFromIfAvailable = core.BNGetHighLevelILVariableReferencesFromIfAvailable
_BNGetHighLevelILVariableReferencesFromIfAvailable.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetHighLevelILVariableReferencesFromIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesFromIfAvailable(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
address: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
result = _BNGetHighLevelILVariableReferencesFromIfAvailable(func, arch, address, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesIfAvailable
_BNGetHighLevelILVariableReferencesIfAvailable = core.BNGetHighLevelILVariableReferencesIfAvailable
_BNGetHighLevelILVariableReferencesIfAvailable.restype = ctypes.POINTER(BNILReferenceSource)
_BNGetHighLevelILVariableReferencesIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesIfAvailable(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNILReferenceSource)]:
result = _BNGetHighLevelILVariableReferencesIfAvailable(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesInRange
_BNGetHighLevelILVariableReferencesInRange = core.BNGetHighLevelILVariableReferencesInRange
_BNGetHighLevelILVariableReferencesInRange.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetHighLevelILVariableReferencesInRange.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesInRange(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
address: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
result = _BNGetHighLevelILVariableReferencesInRange(func, arch, address, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariableReferencesInRangeIfAvailable
_BNGetHighLevelILVariableReferencesInRangeIfAvailable = core.BNGetHighLevelILVariableReferencesInRangeIfAvailable
_BNGetHighLevelILVariableReferencesInRangeIfAvailable.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetHighLevelILVariableReferencesInRangeIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariableReferencesInRangeIfAvailable(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
address: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
result = _BNGetHighLevelILVariableReferencesInRangeIfAvailable(func, arch, address, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariableSSAVersions
_BNGetHighLevelILVariableSSAVersions = core.BNGetHighLevelILVariableSSAVersions
_BNGetHighLevelILVariableSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILVariableSSAVersions.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariableSSAVersions(
func: ctypes.POINTER(BNHighLevelILFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetHighLevelILVariableSSAVersions(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariableUses
_BNGetHighLevelILVariableUses = core.BNGetHighLevelILVariableUses
_BNGetHighLevelILVariableUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetHighLevelILVariableUses.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariableUses(
func: ctypes.POINTER(BNHighLevelILFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetHighLevelILVariableUses(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHighLevelILVariables
_BNGetHighLevelILVariables = core.BNGetHighLevelILVariables
_BNGetHighLevelILVariables.restype = ctypes.POINTER(BNVariable)
_BNGetHighLevelILVariables.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetHighLevelILVariables(
func: ctypes.POINTER(BNHighLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariable)]:
result = _BNGetHighLevelILVariables(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetHorizontalFlowGraphNodeMargin
_BNGetHorizontalFlowGraphNodeMargin = core.BNGetHorizontalFlowGraphNodeMargin
_BNGetHorizontalFlowGraphNodeMargin.restype = ctypes.c_int
_BNGetHorizontalFlowGraphNodeMargin.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNGetHorizontalFlowGraphNodeMargin(
graph: ctypes.POINTER(BNFlowGraph)
) -> int:
return _BNGetHorizontalFlowGraphNodeMargin(graph)
# -------------------------------------------------------
# _BNGetImplicitlyDefinedRegisters
_BNGetImplicitlyDefinedRegisters = core.BNGetImplicitlyDefinedRegisters
_BNGetImplicitlyDefinedRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetImplicitlyDefinedRegisters.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetImplicitlyDefinedRegisters(
cc: ctypes.POINTER(BNCallingConvention),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetImplicitlyDefinedRegisters(cc, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetIncomingDirectTypeReferences
_BNGetIncomingDirectTypeReferences = core.BNGetIncomingDirectTypeReferences
_BNGetIncomingDirectTypeReferences.restype = ctypes.POINTER(BNQualifiedName)
_BNGetIncomingDirectTypeReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetIncomingDirectTypeReferences(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedName)]:
result = _BNGetIncomingDirectTypeReferences(view, type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetIncomingFlagValue
_BNGetIncomingFlagValue = core.BNGetIncomingFlagValue
_BNGetIncomingFlagValue.restype = BNRegisterValue
_BNGetIncomingFlagValue.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.c_uint,
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetIncomingFlagValue(
cc: ctypes.POINTER(BNCallingConvention),
reg: int,
func: ctypes.POINTER(BNFunction)
) -> BNRegisterValue:
return _BNGetIncomingFlagValue(cc, reg, func)
# -------------------------------------------------------
# _BNGetIncomingRecursiveTypeReferences
_BNGetIncomingRecursiveTypeReferences = core.BNGetIncomingRecursiveTypeReferences
_BNGetIncomingRecursiveTypeReferences.restype = ctypes.POINTER(BNQualifiedName)
_BNGetIncomingRecursiveTypeReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetIncomingRecursiveTypeReferences(
view: ctypes.POINTER(BNBinaryView),
types: ctypes.POINTER(BNQualifiedName),
typeCount: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedName)]:
result = _BNGetIncomingRecursiveTypeReferences(view, types, typeCount, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetIncomingRegisterValue
_BNGetIncomingRegisterValue = core.BNGetIncomingRegisterValue
_BNGetIncomingRegisterValue.restype = BNRegisterValue
_BNGetIncomingRegisterValue.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.c_uint,
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetIncomingRegisterValue(
cc: ctypes.POINTER(BNCallingConvention),
reg: int,
func: ctypes.POINTER(BNFunction)
) -> BNRegisterValue:
return _BNGetIncomingRegisterValue(cc, reg, func)
# -------------------------------------------------------
# _BNGetIncomingVariableForParameterVariable
_BNGetIncomingVariableForParameterVariable = core.BNGetIncomingVariableForParameterVariable
_BNGetIncomingVariableForParameterVariable.restype = BNVariable
_BNGetIncomingVariableForParameterVariable.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(BNVariable),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetIncomingVariableForParameterVariable(
cc: ctypes.POINTER(BNCallingConvention),
var: ctypes.POINTER(BNVariable),
func: ctypes.POINTER(BNFunction)
) -> BNVariable:
return _BNGetIncomingVariableForParameterVariable(cc, var, func)
# -------------------------------------------------------
# _BNGetIndirectBranches
_BNGetIndirectBranches = core.BNGetIndirectBranches
_BNGetIndirectBranches.restype = ctypes.POINTER(BNIndirectBranchInfo)
_BNGetIndirectBranches.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetIndirectBranches(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNIndirectBranchInfo)]:
result = _BNGetIndirectBranches(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetIndirectBranchesAt
_BNGetIndirectBranchesAt = core.BNGetIndirectBranchesAt
_BNGetIndirectBranchesAt.restype = ctypes.POINTER(BNIndirectBranchInfo)
_BNGetIndirectBranchesAt.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetIndirectBranchesAt(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNIndirectBranchInfo)]:
result = _BNGetIndirectBranchesAt(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetInstallDirectory
_BNGetInstallDirectory = core.BNGetInstallDirectory
_BNGetInstallDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetInstallDirectory.argtypes = [
]
# noinspection PyPep8Naming
def BNGetInstallDirectory(
) -> Optional[Optional[str]]:
result = _BNGetInstallDirectory()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetInstructionContainingAddress
_BNGetInstructionContainingAddress = core.BNGetInstructionContainingAddress
_BNGetInstructionContainingAddress.restype = ctypes.c_bool
_BNGetInstructionContainingAddress.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetInstructionContainingAddress(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
start: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetInstructionContainingAddress(func, arch, addr, start)
# -------------------------------------------------------
# _BNGetInstructionHighlight
_BNGetInstructionHighlight = core.BNGetInstructionHighlight
_BNGetInstructionHighlight.restype = BNHighlightColor
_BNGetInstructionHighlight.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetInstructionHighlight(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> BNHighlightColor:
return _BNGetInstructionHighlight(func, arch, addr)
# -------------------------------------------------------
# _BNGetInstructionInfo
_BNGetInstructionInfo = core.BNGetInstructionInfo
_BNGetInstructionInfo.restype = ctypes.c_bool
_BNGetInstructionInfo.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(BNInstructionInfo),
]
# noinspection PyPep8Naming
def BNGetInstructionInfo(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
maxLen: int,
result: ctypes.POINTER(BNInstructionInfo)
) -> bool:
return _BNGetInstructionInfo(arch, data, addr, maxLen, result)
# -------------------------------------------------------
# _BNGetInstructionLength
_BNGetInstructionLength = core.BNGetInstructionLength
_BNGetInstructionLength.restype = ctypes.c_ulonglong
_BNGetInstructionLength.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetInstructionLength(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> int:
return _BNGetInstructionLength(view, arch, addr)
# -------------------------------------------------------
# _BNGetInstructionLowLevelIL
_BNGetInstructionLowLevelIL = core.BNGetInstructionLowLevelIL
_BNGetInstructionLowLevelIL.restype = ctypes.c_bool
_BNGetInstructionLowLevelIL.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetInstructionLowLevelIL(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: ctypes.POINTER(ctypes.c_ulonglong),
il: ctypes.POINTER(BNLowLevelILFunction)
) -> bool:
return _BNGetInstructionLowLevelIL(arch, data, addr, len, il)
# -------------------------------------------------------
# _BNGetInstructionText
_BNGetInstructionText = core.BNGetInstructionText
_BNGetInstructionText.restype = ctypes.c_bool
_BNGetInstructionText.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetInstructionText(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: ctypes.POINTER(ctypes.c_ulonglong),
result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetInstructionText(arch, data, addr, len, result, count)
# -------------------------------------------------------
# _BNGetIntegerArgumentRegisters
_BNGetIntegerArgumentRegisters = core.BNGetIntegerArgumentRegisters
_BNGetIntegerArgumentRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetIntegerArgumentRegisters.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetIntegerArgumentRegisters(
cc: ctypes.POINTER(BNCallingConvention),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetIntegerArgumentRegisters(cc, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetIntegerConstantDisplayType
_BNGetIntegerConstantDisplayType = core.BNGetIntegerConstantDisplayType
_BNGetIntegerConstantDisplayType.restype = IntegerDisplayTypeEnum
_BNGetIntegerConstantDisplayType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetIntegerConstantDisplayType(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
instrAddr: int,
value: int,
operand: int
) -> IntegerDisplayType:
return _BNGetIntegerConstantDisplayType(func, arch, instrAddr, value, operand)
# -------------------------------------------------------
# _BNGetIntegerConstantDisplayTypeEnumerationType
_BNGetIntegerConstantDisplayTypeEnumerationType = core.BNGetIntegerConstantDisplayTypeEnumerationType
_BNGetIntegerConstantDisplayTypeEnumerationType.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetIntegerConstantDisplayTypeEnumerationType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetIntegerConstantDisplayTypeEnumerationType(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
instrAddr: int,
value: int,
operand: int
) -> Optional[Optional[str]]:
result = _BNGetIntegerConstantDisplayTypeEnumerationType(func, arch, instrAddr, value, operand)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetIntegerInput
_BNGetIntegerInput = core.BNGetIntegerInput
_BNGetIntegerInput.restype = ctypes.c_bool
_BNGetIntegerInput.argtypes = [
ctypes.POINTER(ctypes.c_longlong),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetIntegerInput(
result: ctypes.POINTER(ctypes.c_longlong),
prompt: Optional[str],
title: Optional[str]
) -> bool:
return _BNGetIntegerInput(result, cstr(prompt), cstr(title))
# -------------------------------------------------------
# _BNGetIntegerReturnValueRegister
_BNGetIntegerReturnValueRegister = core.BNGetIntegerReturnValueRegister
_BNGetIntegerReturnValueRegister.restype = ctypes.c_uint
_BNGetIntegerReturnValueRegister.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNGetIntegerReturnValueRegister(
cc: ctypes.POINTER(BNCallingConvention)
) -> int:
return _BNGetIntegerReturnValueRegister(cc)
# -------------------------------------------------------
# _BNGetIntegerTypeDisplayType
_BNGetIntegerTypeDisplayType = core.BNGetIntegerTypeDisplayType
_BNGetIntegerTypeDisplayType.restype = IntegerDisplayTypeEnum
_BNGetIntegerTypeDisplayType.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetIntegerTypeDisplayType(
type: ctypes.POINTER(BNType)
) -> IntegerDisplayType:
return _BNGetIntegerTypeDisplayType(type)
# -------------------------------------------------------
# _BNGetInternalNameSpace
_BNGetInternalNameSpace = core.BNGetInternalNameSpace
_BNGetInternalNameSpace.restype = BNNameSpace
_BNGetInternalNameSpace.argtypes = [
]
# noinspection PyPep8Naming
def BNGetInternalNameSpace(
) -> BNNameSpace:
return _BNGetInternalNameSpace()
# -------------------------------------------------------
# _BNGetKeyValueStoreBuffer
_BNGetKeyValueStoreBuffer = core.BNGetKeyValueStoreBuffer
_BNGetKeyValueStoreBuffer.restype = ctypes.POINTER(BNDataBuffer)
_BNGetKeyValueStoreBuffer.argtypes = [
ctypes.POINTER(BNKeyValueStore),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetKeyValueStoreBuffer(
store: ctypes.POINTER(BNKeyValueStore),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNGetKeyValueStoreBuffer(store, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetKeyValueStoreDataSize
_BNGetKeyValueStoreDataSize = core.BNGetKeyValueStoreDataSize
_BNGetKeyValueStoreDataSize.restype = ctypes.c_ulonglong
_BNGetKeyValueStoreDataSize.argtypes = [
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNGetKeyValueStoreDataSize(
store: ctypes.POINTER(BNKeyValueStore)
) -> int:
return _BNGetKeyValueStoreDataSize(store)
# -------------------------------------------------------
# _BNGetKeyValueStoreKeys
_BNGetKeyValueStoreKeys = core.BNGetKeyValueStoreKeys
_BNGetKeyValueStoreKeys.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetKeyValueStoreKeys.argtypes = [
ctypes.POINTER(BNKeyValueStore),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetKeyValueStoreKeys(
store: ctypes.POINTER(BNKeyValueStore),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetKeyValueStoreKeys(store, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetKeyValueStoreNamespaceSize
_BNGetKeyValueStoreNamespaceSize = core.BNGetKeyValueStoreNamespaceSize
_BNGetKeyValueStoreNamespaceSize.restype = ctypes.c_ulonglong
_BNGetKeyValueStoreNamespaceSize.argtypes = [
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNGetKeyValueStoreNamespaceSize(
store: ctypes.POINTER(BNKeyValueStore)
) -> int:
return _BNGetKeyValueStoreNamespaceSize(store)
# -------------------------------------------------------
# _BNGetKeyValueStoreSerializedData
_BNGetKeyValueStoreSerializedData = core.BNGetKeyValueStoreSerializedData
_BNGetKeyValueStoreSerializedData.restype = ctypes.POINTER(BNDataBuffer)
_BNGetKeyValueStoreSerializedData.argtypes = [
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNGetKeyValueStoreSerializedData(
store: ctypes.POINTER(BNKeyValueStore)
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNGetKeyValueStoreSerializedData(store)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetKeyValueStoreValue
_BNGetKeyValueStoreValue = core.BNGetKeyValueStoreValue
_BNGetKeyValueStoreValue.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetKeyValueStoreValue.argtypes = [
ctypes.POINTER(BNKeyValueStore),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetKeyValueStoreValue(
store: ctypes.POINTER(BNKeyValueStore),
name: Optional[str]
) -> Optional[Optional[str]]:
result = _BNGetKeyValueStoreValue(store, cstr(name))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetKeyValueStoreValueHash
_BNGetKeyValueStoreValueHash = core.BNGetKeyValueStoreValueHash
_BNGetKeyValueStoreValueHash.restype = ctypes.POINTER(BNDataBuffer)
_BNGetKeyValueStoreValueHash.argtypes = [
ctypes.POINTER(BNKeyValueStore),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetKeyValueStoreValueHash(
store: ctypes.POINTER(BNKeyValueStore),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNGetKeyValueStoreValueHash(store, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetKeyValueStoreValueSize
_BNGetKeyValueStoreValueSize = core.BNGetKeyValueStoreValueSize
_BNGetKeyValueStoreValueSize.restype = ctypes.c_ulonglong
_BNGetKeyValueStoreValueSize.argtypes = [
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNGetKeyValueStoreValueSize(
store: ctypes.POINTER(BNKeyValueStore)
) -> int:
return _BNGetKeyValueStoreValueSize(store)
# -------------------------------------------------------
# _BNGetKeyValueStoreValueStorageSize
_BNGetKeyValueStoreValueStorageSize = core.BNGetKeyValueStoreValueStorageSize
_BNGetKeyValueStoreValueStorageSize.restype = ctypes.c_ulonglong
_BNGetKeyValueStoreValueStorageSize.argtypes = [
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNGetKeyValueStoreValueStorageSize(
store: ctypes.POINTER(BNKeyValueStore)
) -> int:
return _BNGetKeyValueStoreValueStorageSize(store)
# -------------------------------------------------------
# _BNGetLabelForLowLevelILSourceInstruction
_BNGetLabelForLowLevelILSourceInstruction = core.BNGetLabelForLowLevelILSourceInstruction
_BNGetLabelForLowLevelILSourceInstruction.restype = ctypes.POINTER(BNLowLevelILLabel)
_BNGetLabelForLowLevelILSourceInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLabelForLowLevelILSourceInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
instr: int
) -> Optional[ctypes.POINTER(BNLowLevelILLabel)]:
result = _BNGetLabelForLowLevelILSourceInstruction(func, instr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLabelForMediumLevelILSourceInstruction
_BNGetLabelForMediumLevelILSourceInstruction = core.BNGetLabelForMediumLevelILSourceInstruction
_BNGetLabelForMediumLevelILSourceInstruction.restype = ctypes.POINTER(BNMediumLevelILLabel)
_BNGetLabelForMediumLevelILSourceInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLabelForMediumLevelILSourceInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int
) -> Optional[ctypes.POINTER(BNMediumLevelILLabel)]:
result = _BNGetLabelForMediumLevelILSourceInstruction(func, instr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLanguageRepresentationOwnerFunction
_BNGetLanguageRepresentationOwnerFunction = core.BNGetLanguageRepresentationOwnerFunction
_BNGetLanguageRepresentationOwnerFunction.restype = ctypes.POINTER(BNFunction)
_BNGetLanguageRepresentationOwnerFunction.argtypes = [
ctypes.POINTER(BNLanguageRepresentationFunction),
]
# noinspection PyPep8Naming
def BNGetLanguageRepresentationOwnerFunction(
func: ctypes.POINTER(BNLanguageRepresentationFunction)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetLanguageRepresentationOwnerFunction(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLargeChoiceInput
_BNGetLargeChoiceInput = core.BNGetLargeChoiceInput
_BNGetLargeChoiceInput.restype = ctypes.c_bool
_BNGetLargeChoiceInput.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLargeChoiceInput(
result: ctypes.POINTER(ctypes.c_ulonglong),
prompt: Optional[str],
title: Optional[str],
choices: ctypes.POINTER(ctypes.c_char_p),
count: int
) -> bool:
return _BNGetLargeChoiceInput(result, cstr(prompt), cstr(title), choices, count)
# -------------------------------------------------------
# _BNGetLastLinearViewObjectChild
_BNGetLastLinearViewObjectChild = core.BNGetLastLinearViewObjectChild
_BNGetLastLinearViewObjectChild.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLastLinearViewObjectChild.argtypes = [
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNGetLastLinearViewObjectChild(
obj: ctypes.POINTER(BNLinearViewObject)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNGetLastLinearViewObjectChild(obj)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLastRedoEntry
_BNGetLastRedoEntry = core.BNGetLastRedoEntry
_BNGetLastRedoEntry.restype = BNUndoEntry
_BNGetLastRedoEntry.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetLastRedoEntry(
file: ctypes.POINTER(BNFileMetadata)
) -> BNUndoEntry:
return _BNGetLastRedoEntry(file)
# -------------------------------------------------------
# _BNGetLastRedoEntryTitle
_BNGetLastRedoEntryTitle = core.BNGetLastRedoEntryTitle
_BNGetLastRedoEntryTitle.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetLastRedoEntryTitle.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetLastRedoEntryTitle(
file: ctypes.POINTER(BNFileMetadata)
) -> Optional[Optional[str]]:
result = _BNGetLastRedoEntryTitle(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetLastSeenVariableNameOrDefault
_BNGetLastSeenVariableNameOrDefault = core.BNGetLastSeenVariableNameOrDefault
_BNGetLastSeenVariableNameOrDefault.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetLastSeenVariableNameOrDefault.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNGetLastSeenVariableNameOrDefault(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable)
) -> Optional[Optional[str]]:
result = _BNGetLastSeenVariableNameOrDefault(func, var)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetLastUndoEntry
_BNGetLastUndoEntry = core.BNGetLastUndoEntry
_BNGetLastUndoEntry.restype = BNUndoEntry
_BNGetLastUndoEntry.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetLastUndoEntry(
file: ctypes.POINTER(BNFileMetadata)
) -> BNUndoEntry:
return _BNGetLastUndoEntry(file)
# -------------------------------------------------------
# _BNGetLastUndoEntryTitle
_BNGetLastUndoEntryTitle = core.BNGetLastUndoEntryTitle
_BNGetLastUndoEntryTitle.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetLastUndoEntryTitle.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetLastUndoEntryTitle(
file: ctypes.POINTER(BNFileMetadata)
) -> Optional[Optional[str]]:
result = _BNGetLastUndoEntryTitle(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetLicenseCount
_BNGetLicenseCount = core.BNGetLicenseCount
_BNGetLicenseCount.restype = ctypes.c_int
_BNGetLicenseCount.argtypes = [
]
# noinspection PyPep8Naming
def BNGetLicenseCount(
) -> int:
return _BNGetLicenseCount()
# -------------------------------------------------------
# _BNGetLicenseExpirationTime
_BNGetLicenseExpirationTime = core.BNGetLicenseExpirationTime
_BNGetLicenseExpirationTime.restype = ctypes.c_ulonglong
_BNGetLicenseExpirationTime.argtypes = [
]
# noinspection PyPep8Naming
def BNGetLicenseExpirationTime(
) -> int:
return _BNGetLicenseExpirationTime()
# -------------------------------------------------------
# _BNGetLicensedUserEmail
_BNGetLicensedUserEmail = core.BNGetLicensedUserEmail
_BNGetLicensedUserEmail.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetLicensedUserEmail.argtypes = [
]
# noinspection PyPep8Naming
def BNGetLicensedUserEmail(
) -> Optional[Optional[str]]:
result = _BNGetLicensedUserEmail()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetLiftedILFlagDefinitionsForUse
_BNGetLiftedILFlagDefinitionsForUse = core.BNGetLiftedILFlagDefinitionsForUse
_BNGetLiftedILFlagDefinitionsForUse.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLiftedILFlagDefinitionsForUse.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLiftedILFlagDefinitionsForUse(
func: ctypes.POINTER(BNFunction),
i: int,
flag: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLiftedILFlagDefinitionsForUse(func, i, flag, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLiftedILFlagUsesForDefinition
_BNGetLiftedILFlagUsesForDefinition = core.BNGetLiftedILFlagUsesForDefinition
_BNGetLiftedILFlagUsesForDefinition.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLiftedILFlagUsesForDefinition.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLiftedILFlagUsesForDefinition(
func: ctypes.POINTER(BNFunction),
i: int,
flag: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLiftedILFlagUsesForDefinition(func, i, flag, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLiftedILForInstruction
_BNGetLiftedILForInstruction = core.BNGetLiftedILForInstruction
_BNGetLiftedILForInstruction.restype = ctypes.c_ulonglong
_BNGetLiftedILForInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLiftedILForInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> int:
return _BNGetLiftedILForInstruction(func, arch, addr)
# -------------------------------------------------------
# _BNGetLiftedILInstructionsForAddress
_BNGetLiftedILInstructionsForAddress = core.BNGetLiftedILInstructionsForAddress
_BNGetLiftedILInstructionsForAddress.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLiftedILInstructionsForAddress.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLiftedILInstructionsForAddress(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLiftedILInstructionsForAddress(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLinearViewCursorCurrentObject
_BNGetLinearViewCursorCurrentObject = core.BNGetLinearViewCursorCurrentObject
_BNGetLinearViewCursorCurrentObject.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLinearViewCursorCurrentObject.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNGetLinearViewCursorCurrentObject(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNGetLinearViewCursorCurrentObject(cursor)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLinearViewCursorLines
_BNGetLinearViewCursorLines = core.BNGetLinearViewCursorLines
_BNGetLinearViewCursorLines.restype = ctypes.POINTER(BNLinearDisassemblyLine)
_BNGetLinearViewCursorLines.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLinearViewCursorLines(
cursor: ctypes.POINTER(BNLinearViewCursor),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNLinearDisassemblyLine)]:
result = _BNGetLinearViewCursorLines(cursor, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLinearViewCursorOrderingIndex
_BNGetLinearViewCursorOrderingIndex = core.BNGetLinearViewCursorOrderingIndex
_BNGetLinearViewCursorOrderingIndex.restype = BNAddressRange
_BNGetLinearViewCursorOrderingIndex.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNGetLinearViewCursorOrderingIndex(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> BNAddressRange:
return _BNGetLinearViewCursorOrderingIndex(cursor)
# -------------------------------------------------------
# _BNGetLinearViewCursorOrderingIndexTotal
_BNGetLinearViewCursorOrderingIndexTotal = core.BNGetLinearViewCursorOrderingIndexTotal
_BNGetLinearViewCursorOrderingIndexTotal.restype = ctypes.c_ulonglong
_BNGetLinearViewCursorOrderingIndexTotal.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNGetLinearViewCursorOrderingIndexTotal(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> int:
return _BNGetLinearViewCursorOrderingIndexTotal(cursor)
# -------------------------------------------------------
# _BNGetLinearViewCursorPath
_BNGetLinearViewCursorPath = core.BNGetLinearViewCursorPath
_BNGetLinearViewCursorPath.restype = ctypes.POINTER(BNLinearViewObjectIdentifier)
_BNGetLinearViewCursorPath.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLinearViewCursorPath(
cursor: ctypes.POINTER(BNLinearViewCursor),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNLinearViewObjectIdentifier)]:
result = _BNGetLinearViewCursorPath(cursor, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLinearViewCursorPathObjects
_BNGetLinearViewCursorPathObjects = core.BNGetLinearViewCursorPathObjects
_BNGetLinearViewCursorPathObjects.restype = ctypes.POINTER(ctypes.POINTER(BNLinearViewObject))
_BNGetLinearViewCursorPathObjects.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLinearViewCursorPathObjects(
cursor: ctypes.POINTER(BNLinearViewCursor),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNLinearViewObject))]:
result = _BNGetLinearViewCursorPathObjects(cursor, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLinearViewObjectChildForAddress
_BNGetLinearViewObjectChildForAddress = core.BNGetLinearViewObjectChildForAddress
_BNGetLinearViewObjectChildForAddress.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLinearViewObjectChildForAddress.argtypes = [
ctypes.POINTER(BNLinearViewObject),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLinearViewObjectChildForAddress(
parent: ctypes.POINTER(BNLinearViewObject),
addr: int
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNGetLinearViewObjectChildForAddress(parent, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLinearViewObjectChildForIdentifier
_BNGetLinearViewObjectChildForIdentifier = core.BNGetLinearViewObjectChildForIdentifier
_BNGetLinearViewObjectChildForIdentifier.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLinearViewObjectChildForIdentifier.argtypes = [
ctypes.POINTER(BNLinearViewObject),
ctypes.POINTER(BNLinearViewObjectIdentifier),
]
# noinspection PyPep8Naming
def BNGetLinearViewObjectChildForIdentifier(
parent: ctypes.POINTER(BNLinearViewObject),
id: ctypes.POINTER(BNLinearViewObjectIdentifier)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNGetLinearViewObjectChildForIdentifier(parent, id)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLinearViewObjectChildForOrderingIndex
_BNGetLinearViewObjectChildForOrderingIndex = core.BNGetLinearViewObjectChildForOrderingIndex
_BNGetLinearViewObjectChildForOrderingIndex.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetLinearViewObjectChildForOrderingIndex.argtypes = [
ctypes.POINTER(BNLinearViewObject),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLinearViewObjectChildForOrderingIndex(
parent: ctypes.POINTER(BNLinearViewObject),
idx: int
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNGetLinearViewObjectChildForOrderingIndex(parent, idx)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLinearViewObjectEnd
_BNGetLinearViewObjectEnd = core.BNGetLinearViewObjectEnd
_BNGetLinearViewObjectEnd.restype = ctypes.c_ulonglong
_BNGetLinearViewObjectEnd.argtypes = [
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNGetLinearViewObjectEnd(
obj: ctypes.POINTER(BNLinearViewObject)
) -> int:
return _BNGetLinearViewObjectEnd(obj)
# -------------------------------------------------------
# _BNGetLinearViewObjectIdentifier
_BNGetLinearViewObjectIdentifier = core.BNGetLinearViewObjectIdentifier
_BNGetLinearViewObjectIdentifier.restype = BNLinearViewObjectIdentifier
_BNGetLinearViewObjectIdentifier.argtypes = [
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNGetLinearViewObjectIdentifier(
obj: ctypes.POINTER(BNLinearViewObject)
) -> BNLinearViewObjectIdentifier:
return _BNGetLinearViewObjectIdentifier(obj)
# -------------------------------------------------------
# _BNGetLinearViewObjectLines
_BNGetLinearViewObjectLines = core.BNGetLinearViewObjectLines
_BNGetLinearViewObjectLines.restype = ctypes.POINTER(BNLinearDisassemblyLine)
_BNGetLinearViewObjectLines.argtypes = [
ctypes.POINTER(BNLinearViewObject),
ctypes.POINTER(BNLinearViewObject),
ctypes.POINTER(BNLinearViewObject),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLinearViewObjectLines(
obj: ctypes.POINTER(BNLinearViewObject),
prev: ctypes.POINTER(BNLinearViewObject),
next: ctypes.POINTER(BNLinearViewObject),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNLinearDisassemblyLine)]:
result = _BNGetLinearViewObjectLines(obj, prev, next, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLinearViewObjectOrderingIndexForChild
_BNGetLinearViewObjectOrderingIndexForChild = core.BNGetLinearViewObjectOrderingIndexForChild
_BNGetLinearViewObjectOrderingIndexForChild.restype = ctypes.c_ulonglong
_BNGetLinearViewObjectOrderingIndexForChild.argtypes = [
ctypes.POINTER(BNLinearViewObject),
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNGetLinearViewObjectOrderingIndexForChild(
parent: ctypes.POINTER(BNLinearViewObject),
child: ctypes.POINTER(BNLinearViewObject)
) -> int:
return _BNGetLinearViewObjectOrderingIndexForChild(parent, child)
# -------------------------------------------------------
# _BNGetLinearViewObjectOrderingIndexTotal
_BNGetLinearViewObjectOrderingIndexTotal = core.BNGetLinearViewObjectOrderingIndexTotal
_BNGetLinearViewObjectOrderingIndexTotal.restype = ctypes.c_ulonglong
_BNGetLinearViewObjectOrderingIndexTotal.argtypes = [
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNGetLinearViewObjectOrderingIndexTotal(
obj: ctypes.POINTER(BNLinearViewObject)
) -> int:
return _BNGetLinearViewObjectOrderingIndexTotal(obj)
# -------------------------------------------------------
# _BNGetLinearViewObjectStart
_BNGetLinearViewObjectStart = core.BNGetLinearViewObjectStart
_BNGetLinearViewObjectStart.restype = ctypes.c_ulonglong
_BNGetLinearViewObjectStart.argtypes = [
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNGetLinearViewObjectStart(
obj: ctypes.POINTER(BNLinearViewObject)
) -> int:
return _BNGetLinearViewObjectStart(obj)
# -------------------------------------------------------
# _BNGetLinesForData
_BNGetLinesForData = core.BNGetLinesForData
_BNGetLinesForData.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNGetLinesForData.argtypes = [
ctypes.c_void_p,
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNType),
ctypes.POINTER(BNInstructionTextToken),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNTypeContext),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLinesForData(
ctxt: Optional[ctypes.c_void_p],
view: ctypes.POINTER(BNBinaryView),
addr: int,
type: ctypes.POINTER(BNType),
prefix: ctypes.POINTER(BNInstructionTextToken),
prefixCount: int,
width: int,
count: ctypes.POINTER(ctypes.c_ulonglong),
typeCtx: ctypes.POINTER(BNTypeContext),
ctxCount: int
) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
result = _BNGetLinesForData(ctxt, view, addr, type, prefix, prefixCount, width, count, typeCtx, ctxCount)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelFlagSSAVersions
_BNGetLowLevelFlagSSAVersions = core.BNGetLowLevelFlagSSAVersions
_BNGetLowLevelFlagSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelFlagSSAVersions.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelFlagSSAVersions(
func: ctypes.POINTER(BNLowLevelILFunction),
var: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelFlagSSAVersions(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelFlags
_BNGetLowLevelFlags = core.BNGetLowLevelFlags
_BNGetLowLevelFlags.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelFlags.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelFlags(
func: ctypes.POINTER(BNLowLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetLowLevelFlags(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILBasicBlockForInstruction
_BNGetLowLevelILBasicBlockForInstruction = core.BNGetLowLevelILBasicBlockForInstruction
_BNGetLowLevelILBasicBlockForInstruction.restype = ctypes.POINTER(BNBasicBlock)
_BNGetLowLevelILBasicBlockForInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILBasicBlockForInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
i: int
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetLowLevelILBasicBlockForInstruction(func, i)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILBasicBlockList
_BNGetLowLevelILBasicBlockList = core.BNGetLowLevelILBasicBlockList
_BNGetLowLevelILBasicBlockList.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetLowLevelILBasicBlockList.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelILBasicBlockList(
func: ctypes.POINTER(BNLowLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetLowLevelILBasicBlockList(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILByIndex
_BNGetLowLevelILByIndex = core.BNGetLowLevelILByIndex
_BNGetLowLevelILByIndex.restype = BNLowLevelILInstruction
_BNGetLowLevelILByIndex.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILByIndex(
func: ctypes.POINTER(BNLowLevelILFunction),
i: int
) -> BNLowLevelILInstruction:
return _BNGetLowLevelILByIndex(func, i)
# -------------------------------------------------------
# _BNGetLowLevelILExitsForInstruction
_BNGetLowLevelILExitsForInstruction = core.BNGetLowLevelILExitsForInstruction
_BNGetLowLevelILExitsForInstruction.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILExitsForInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelILExitsForInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelILExitsForInstruction(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILExprCount
_BNGetLowLevelILExprCount = core.BNGetLowLevelILExprCount
_BNGetLowLevelILExprCount.restype = ctypes.c_ulonglong
_BNGetLowLevelILExprCount.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetLowLevelILExprCount(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNGetLowLevelILExprCount(func)
# -------------------------------------------------------
# _BNGetLowLevelILExprIndex
_BNGetLowLevelILExprIndex = core.BNGetLowLevelILExprIndex
_BNGetLowLevelILExprIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILExprIndex.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILExprIndex(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int
) -> int:
return _BNGetLowLevelILExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetLowLevelILExprIndexes
_BNGetLowLevelILExprIndexes = core.BNGetLowLevelILExprIndexes
_BNGetLowLevelILExprIndexes.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILExprIndexes.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelILExprIndexes(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelILExprIndexes(func, expr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILExprText
_BNGetLowLevelILExprText = core.BNGetLowLevelILExprText
_BNGetLowLevelILExprText.restype = ctypes.c_bool
_BNGetLowLevelILExprText.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNDisassemblySettings),
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelILExprText(
func: ctypes.POINTER(BNLowLevelILFunction),
arch: ctypes.POINTER(BNArchitecture),
i: int,
settings: ctypes.POINTER(BNDisassemblySettings),
tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetLowLevelILExprText(func, arch, i, settings, tokens, count)
# -------------------------------------------------------
# _BNGetLowLevelILExprValue
_BNGetLowLevelILExprValue = core.BNGetLowLevelILExprValue
_BNGetLowLevelILExprValue.restype = BNRegisterValue
_BNGetLowLevelILExprValue.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILExprValue(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int
) -> BNRegisterValue:
return _BNGetLowLevelILExprValue(func, expr)
# -------------------------------------------------------
# _BNGetLowLevelILFlagValueAfterInstruction
_BNGetLowLevelILFlagValueAfterInstruction = core.BNGetLowLevelILFlagValueAfterInstruction
_BNGetLowLevelILFlagValueAfterInstruction.restype = BNRegisterValue
_BNGetLowLevelILFlagValueAfterInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILFlagValueAfterInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
flag: int,
instr: int
) -> BNRegisterValue:
return _BNGetLowLevelILFlagValueAfterInstruction(func, flag, instr)
# -------------------------------------------------------
# _BNGetLowLevelILFlagValueAtInstruction
_BNGetLowLevelILFlagValueAtInstruction = core.BNGetLowLevelILFlagValueAtInstruction
_BNGetLowLevelILFlagValueAtInstruction.restype = BNRegisterValue
_BNGetLowLevelILFlagValueAtInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILFlagValueAtInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
flag: int,
instr: int
) -> BNRegisterValue:
return _BNGetLowLevelILFlagValueAtInstruction(func, flag, instr)
# -------------------------------------------------------
# _BNGetLowLevelILForInstruction
_BNGetLowLevelILForInstruction = core.BNGetLowLevelILForInstruction
_BNGetLowLevelILForInstruction.restype = ctypes.c_ulonglong
_BNGetLowLevelILForInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILForInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> int:
return _BNGetLowLevelILForInstruction(func, arch, addr)
# -------------------------------------------------------
# _BNGetLowLevelILForMediumLevelIL
_BNGetLowLevelILForMediumLevelIL = core.BNGetLowLevelILForMediumLevelIL
_BNGetLowLevelILForMediumLevelIL.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetLowLevelILForMediumLevelIL.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetLowLevelILForMediumLevelIL(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetLowLevelILForMediumLevelIL(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILIndexForInstruction
_BNGetLowLevelILIndexForInstruction = core.BNGetLowLevelILIndexForInstruction
_BNGetLowLevelILIndexForInstruction.restype = ctypes.c_ulonglong
_BNGetLowLevelILIndexForInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILIndexForInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
i: int
) -> int:
return _BNGetLowLevelILIndexForInstruction(func, i)
# -------------------------------------------------------
# _BNGetLowLevelILInstructionCount
_BNGetLowLevelILInstructionCount = core.BNGetLowLevelILInstructionCount
_BNGetLowLevelILInstructionCount.restype = ctypes.c_ulonglong
_BNGetLowLevelILInstructionCount.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetLowLevelILInstructionCount(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNGetLowLevelILInstructionCount(func)
# -------------------------------------------------------
# _BNGetLowLevelILInstructionForExpr
_BNGetLowLevelILInstructionForExpr = core.BNGetLowLevelILInstructionForExpr
_BNGetLowLevelILInstructionForExpr.restype = ctypes.c_ulonglong
_BNGetLowLevelILInstructionForExpr.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILInstructionForExpr(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int
) -> int:
return _BNGetLowLevelILInstructionForExpr(func, expr)
# -------------------------------------------------------
# _BNGetLowLevelILInstructionIndex
_BNGetLowLevelILInstructionIndex = core.BNGetLowLevelILInstructionIndex
_BNGetLowLevelILInstructionIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILInstructionIndex.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILInstructionIndex(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int
) -> int:
return _BNGetLowLevelILInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetLowLevelILInstructionText
_BNGetLowLevelILInstructionText = core.BNGetLowLevelILInstructionText
_BNGetLowLevelILInstructionText.restype = ctypes.c_bool
_BNGetLowLevelILInstructionText.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNDisassemblySettings),
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelILInstructionText(
il: ctypes.POINTER(BNLowLevelILFunction),
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
i: int,
settings: ctypes.POINTER(BNDisassemblySettings),
tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetLowLevelILInstructionText(il, func, arch, i, settings, tokens, count)
# -------------------------------------------------------
# _BNGetLowLevelILInstructionsForAddress
_BNGetLowLevelILInstructionsForAddress = core.BNGetLowLevelILInstructionsForAddress
_BNGetLowLevelILInstructionsForAddress.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILInstructionsForAddress.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelILInstructionsForAddress(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelILInstructionsForAddress(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILLabelForAddress
_BNGetLowLevelILLabelForAddress = core.BNGetLowLevelILLabelForAddress
_BNGetLowLevelILLabelForAddress.restype = ctypes.POINTER(BNLowLevelILLabel)
_BNGetLowLevelILLabelForAddress.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILLabelForAddress(
func: ctypes.POINTER(BNLowLevelILFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> Optional[ctypes.POINTER(BNLowLevelILLabel)]:
result = _BNGetLowLevelILLabelForAddress(func, arch, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILNonSSAExprIndex
_BNGetLowLevelILNonSSAExprIndex = core.BNGetLowLevelILNonSSAExprIndex
_BNGetLowLevelILNonSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILNonSSAExprIndex.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILNonSSAExprIndex(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int
) -> int:
return _BNGetLowLevelILNonSSAExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetLowLevelILNonSSAForm
_BNGetLowLevelILNonSSAForm = core.BNGetLowLevelILNonSSAForm
_BNGetLowLevelILNonSSAForm.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetLowLevelILNonSSAForm.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetLowLevelILNonSSAForm(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetLowLevelILNonSSAForm(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILNonSSAInstructionIndex
_BNGetLowLevelILNonSSAInstructionIndex = core.BNGetLowLevelILNonSSAInstructionIndex
_BNGetLowLevelILNonSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILNonSSAInstructionIndex.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILNonSSAInstructionIndex(
func: ctypes.POINTER(BNLowLevelILFunction),
instr: int
) -> int:
return _BNGetLowLevelILNonSSAInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetLowLevelILOwnerFunction
_BNGetLowLevelILOwnerFunction = core.BNGetLowLevelILOwnerFunction
_BNGetLowLevelILOwnerFunction.restype = ctypes.POINTER(BNFunction)
_BNGetLowLevelILOwnerFunction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetLowLevelILOwnerFunction(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetLowLevelILOwnerFunction(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILPossibleExprValues
_BNGetLowLevelILPossibleExprValues = core.BNGetLowLevelILPossibleExprValues
_BNGetLowLevelILPossibleExprValues.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleExprValues.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILPossibleExprValues(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetLowLevelILPossibleExprValues(func, expr, options, optionCount)
# -------------------------------------------------------
# _BNGetLowLevelILPossibleFlagValuesAfterInstruction
_BNGetLowLevelILPossibleFlagValuesAfterInstruction = core.BNGetLowLevelILPossibleFlagValuesAfterInstruction
_BNGetLowLevelILPossibleFlagValuesAfterInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleFlagValuesAfterInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILPossibleFlagValuesAfterInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
flag: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetLowLevelILPossibleFlagValuesAfterInstruction(func, flag, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetLowLevelILPossibleFlagValuesAtInstruction
_BNGetLowLevelILPossibleFlagValuesAtInstruction = core.BNGetLowLevelILPossibleFlagValuesAtInstruction
_BNGetLowLevelILPossibleFlagValuesAtInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleFlagValuesAtInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILPossibleFlagValuesAtInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
flag: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetLowLevelILPossibleFlagValuesAtInstruction(func, flag, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetLowLevelILPossibleRegisterValuesAfterInstruction
_BNGetLowLevelILPossibleRegisterValuesAfterInstruction = core.BNGetLowLevelILPossibleRegisterValuesAfterInstruction
_BNGetLowLevelILPossibleRegisterValuesAfterInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleRegisterValuesAfterInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILPossibleRegisterValuesAfterInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
reg: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetLowLevelILPossibleRegisterValuesAfterInstruction(func, reg, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetLowLevelILPossibleRegisterValuesAtInstruction
_BNGetLowLevelILPossibleRegisterValuesAtInstruction = core.BNGetLowLevelILPossibleRegisterValuesAtInstruction
_BNGetLowLevelILPossibleRegisterValuesAtInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleRegisterValuesAtInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILPossibleRegisterValuesAtInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
reg: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetLowLevelILPossibleRegisterValuesAtInstruction(func, reg, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetLowLevelILPossibleStackContentsAfterInstruction
_BNGetLowLevelILPossibleStackContentsAfterInstruction = core.BNGetLowLevelILPossibleStackContentsAfterInstruction
_BNGetLowLevelILPossibleStackContentsAfterInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleStackContentsAfterInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_longlong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILPossibleStackContentsAfterInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
offset: int,
len: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetLowLevelILPossibleStackContentsAfterInstruction(func, offset, len, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetLowLevelILPossibleStackContentsAtInstruction
_BNGetLowLevelILPossibleStackContentsAtInstruction = core.BNGetLowLevelILPossibleStackContentsAtInstruction
_BNGetLowLevelILPossibleStackContentsAtInstruction.restype = BNPossibleValueSet
_BNGetLowLevelILPossibleStackContentsAtInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_longlong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILPossibleStackContentsAtInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
offset: int,
len: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetLowLevelILPossibleStackContentsAtInstruction(func, offset, len, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetLowLevelILRegisterValueAfterInstruction
_BNGetLowLevelILRegisterValueAfterInstruction = core.BNGetLowLevelILRegisterValueAfterInstruction
_BNGetLowLevelILRegisterValueAfterInstruction.restype = BNRegisterValue
_BNGetLowLevelILRegisterValueAfterInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILRegisterValueAfterInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
reg: int,
instr: int
) -> BNRegisterValue:
return _BNGetLowLevelILRegisterValueAfterInstruction(func, reg, instr)
# -------------------------------------------------------
# _BNGetLowLevelILRegisterValueAtInstruction
_BNGetLowLevelILRegisterValueAtInstruction = core.BNGetLowLevelILRegisterValueAtInstruction
_BNGetLowLevelILRegisterValueAtInstruction.restype = BNRegisterValue
_BNGetLowLevelILRegisterValueAtInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILRegisterValueAtInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
reg: int,
instr: int
) -> BNRegisterValue:
return _BNGetLowLevelILRegisterValueAtInstruction(func, reg, instr)
# -------------------------------------------------------
# _BNGetLowLevelILSSAExprIndex
_BNGetLowLevelILSSAExprIndex = core.BNGetLowLevelILSSAExprIndex
_BNGetLowLevelILSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSAExprIndex.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSAExprIndex(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int
) -> int:
return _BNGetLowLevelILSSAExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetLowLevelILSSAFlagDefinition
_BNGetLowLevelILSSAFlagDefinition = core.BNGetLowLevelILSSAFlagDefinition
_BNGetLowLevelILSSAFlagDefinition.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSAFlagDefinition.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSAFlagDefinition(
func: ctypes.POINTER(BNLowLevelILFunction),
reg: int,
version: int
) -> int:
return _BNGetLowLevelILSSAFlagDefinition(func, reg, version)
# -------------------------------------------------------
# _BNGetLowLevelILSSAFlagUses
_BNGetLowLevelILSSAFlagUses = core.BNGetLowLevelILSSAFlagUses
_BNGetLowLevelILSSAFlagUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILSSAFlagUses.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSAFlagUses(
func: ctypes.POINTER(BNLowLevelILFunction),
reg: int,
version: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelILSSAFlagUses(func, reg, version, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILSSAFlagValue
_BNGetLowLevelILSSAFlagValue = core.BNGetLowLevelILSSAFlagValue
_BNGetLowLevelILSSAFlagValue.restype = BNRegisterValue
_BNGetLowLevelILSSAFlagValue.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSAFlagValue(
func: ctypes.POINTER(BNLowLevelILFunction),
flag: int,
version: int
) -> BNRegisterValue:
return _BNGetLowLevelILSSAFlagValue(func, flag, version)
# -------------------------------------------------------
# _BNGetLowLevelILSSAForm
_BNGetLowLevelILSSAForm = core.BNGetLowLevelILSSAForm
_BNGetLowLevelILSSAForm.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNGetLowLevelILSSAForm.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSAForm(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNGetLowLevelILSSAForm(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILSSAInstructionIndex
_BNGetLowLevelILSSAInstructionIndex = core.BNGetLowLevelILSSAInstructionIndex
_BNGetLowLevelILSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSAInstructionIndex.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSAInstructionIndex(
func: ctypes.POINTER(BNLowLevelILFunction),
instr: int
) -> int:
return _BNGetLowLevelILSSAInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetLowLevelILSSAMemoryDefinition
_BNGetLowLevelILSSAMemoryDefinition = core.BNGetLowLevelILSSAMemoryDefinition
_BNGetLowLevelILSSAMemoryDefinition.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSAMemoryDefinition.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSAMemoryDefinition(
func: ctypes.POINTER(BNLowLevelILFunction),
version: int
) -> int:
return _BNGetLowLevelILSSAMemoryDefinition(func, version)
# -------------------------------------------------------
# _BNGetLowLevelILSSAMemoryUses
_BNGetLowLevelILSSAMemoryUses = core.BNGetLowLevelILSSAMemoryUses
_BNGetLowLevelILSSAMemoryUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILSSAMemoryUses.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSAMemoryUses(
func: ctypes.POINTER(BNLowLevelILFunction),
version: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelILSSAMemoryUses(func, version, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILSSARegisterDefinition
_BNGetLowLevelILSSARegisterDefinition = core.BNGetLowLevelILSSARegisterDefinition
_BNGetLowLevelILSSARegisterDefinition.restype = ctypes.c_ulonglong
_BNGetLowLevelILSSARegisterDefinition.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSARegisterDefinition(
func: ctypes.POINTER(BNLowLevelILFunction),
reg: int,
version: int
) -> int:
return _BNGetLowLevelILSSARegisterDefinition(func, reg, version)
# -------------------------------------------------------
# _BNGetLowLevelILSSARegisterUses
_BNGetLowLevelILSSARegisterUses = core.BNGetLowLevelILSSARegisterUses
_BNGetLowLevelILSSARegisterUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelILSSARegisterUses.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSARegisterUses(
func: ctypes.POINTER(BNLowLevelILFunction),
reg: int,
version: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelILSSARegisterUses(func, reg, version, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelILSSARegisterValue
_BNGetLowLevelILSSARegisterValue = core.BNGetLowLevelILSSARegisterValue
_BNGetLowLevelILSSARegisterValue.restype = BNRegisterValue
_BNGetLowLevelILSSARegisterValue.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILSSARegisterValue(
func: ctypes.POINTER(BNLowLevelILFunction),
reg: int,
version: int
) -> BNRegisterValue:
return _BNGetLowLevelILSSARegisterValue(func, reg, version)
# -------------------------------------------------------
# _BNGetLowLevelILStackContentsAfterInstruction
_BNGetLowLevelILStackContentsAfterInstruction = core.BNGetLowLevelILStackContentsAfterInstruction
_BNGetLowLevelILStackContentsAfterInstruction.restype = BNRegisterValue
_BNGetLowLevelILStackContentsAfterInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_longlong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILStackContentsAfterInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
offset: int,
len: int,
instr: int
) -> BNRegisterValue:
return _BNGetLowLevelILStackContentsAfterInstruction(func, offset, len, instr)
# -------------------------------------------------------
# _BNGetLowLevelILStackContentsAtInstruction
_BNGetLowLevelILStackContentsAtInstruction = core.BNGetLowLevelILStackContentsAtInstruction
_BNGetLowLevelILStackContentsAtInstruction.restype = BNRegisterValue
_BNGetLowLevelILStackContentsAtInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_longlong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetLowLevelILStackContentsAtInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
offset: int,
len: int,
instr: int
) -> BNRegisterValue:
return _BNGetLowLevelILStackContentsAtInstruction(func, offset, len, instr)
# -------------------------------------------------------
# _BNGetLowLevelILTemporaryFlagCount
_BNGetLowLevelILTemporaryFlagCount = core.BNGetLowLevelILTemporaryFlagCount
_BNGetLowLevelILTemporaryFlagCount.restype = ctypes.c_uint
_BNGetLowLevelILTemporaryFlagCount.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetLowLevelILTemporaryFlagCount(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNGetLowLevelILTemporaryFlagCount(func)
# -------------------------------------------------------
# _BNGetLowLevelILTemporaryRegisterCount
_BNGetLowLevelILTemporaryRegisterCount = core.BNGetLowLevelILTemporaryRegisterCount
_BNGetLowLevelILTemporaryRegisterCount.restype = ctypes.c_uint
_BNGetLowLevelILTemporaryRegisterCount.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetLowLevelILTemporaryRegisterCount(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNGetLowLevelILTemporaryRegisterCount(func)
# -------------------------------------------------------
# _BNGetLowLevelMemoryVersions
_BNGetLowLevelMemoryVersions = core.BNGetLowLevelMemoryVersions
_BNGetLowLevelMemoryVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelMemoryVersions.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelMemoryVersions(
func: ctypes.POINTER(BNLowLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelMemoryVersions(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelRegisterSSAVersions
_BNGetLowLevelRegisterSSAVersions = core.BNGetLowLevelRegisterSSAVersions
_BNGetLowLevelRegisterSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelRegisterSSAVersions.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelRegisterSSAVersions(
func: ctypes.POINTER(BNLowLevelILFunction),
var: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelRegisterSSAVersions(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelRegisterStackSSAVersions
_BNGetLowLevelRegisterStackSSAVersions = core.BNGetLowLevelRegisterStackSSAVersions
_BNGetLowLevelRegisterStackSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetLowLevelRegisterStackSSAVersions.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelRegisterStackSSAVersions(
func: ctypes.POINTER(BNLowLevelILFunction),
var: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetLowLevelRegisterStackSSAVersions(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelRegisterStacks
_BNGetLowLevelRegisterStacks = core.BNGetLowLevelRegisterStacks
_BNGetLowLevelRegisterStacks.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelRegisterStacks.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelRegisterStacks(
func: ctypes.POINTER(BNLowLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetLowLevelRegisterStacks(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelRegisters
_BNGetLowLevelRegisters = core.BNGetLowLevelRegisters
_BNGetLowLevelRegisters.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelRegisters.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelRegisters(
func: ctypes.POINTER(BNLowLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetLowLevelRegisters(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelSSAFlagsWithoutVersions
_BNGetLowLevelSSAFlagsWithoutVersions = core.BNGetLowLevelSSAFlagsWithoutVersions
_BNGetLowLevelSSAFlagsWithoutVersions.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelSSAFlagsWithoutVersions.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelSSAFlagsWithoutVersions(
func: ctypes.POINTER(BNLowLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetLowLevelSSAFlagsWithoutVersions(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelSSARegisterStacksWithoutVersions
_BNGetLowLevelSSARegisterStacksWithoutVersions = core.BNGetLowLevelSSARegisterStacksWithoutVersions
_BNGetLowLevelSSARegisterStacksWithoutVersions.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelSSARegisterStacksWithoutVersions.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelSSARegisterStacksWithoutVersions(
func: ctypes.POINTER(BNLowLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetLowLevelSSARegisterStacksWithoutVersions(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetLowLevelSSARegistersWithoutVersions
_BNGetLowLevelSSARegistersWithoutVersions = core.BNGetLowLevelSSARegistersWithoutVersions
_BNGetLowLevelSSARegistersWithoutVersions.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetLowLevelSSARegistersWithoutVersions.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetLowLevelSSARegistersWithoutVersions(
func: ctypes.POINTER(BNLowLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetLowLevelSSARegistersWithoutVersions(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMappedMediumLevelIL
_BNGetMappedMediumLevelIL = core.BNGetMappedMediumLevelIL
_BNGetMappedMediumLevelIL.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMappedMediumLevelIL.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetMappedMediumLevelIL(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetMappedMediumLevelIL(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMappedMediumLevelILExprIndex
_BNGetMappedMediumLevelILExprIndex = core.BNGetMappedMediumLevelILExprIndex
_BNGetMappedMediumLevelILExprIndex.restype = ctypes.c_ulonglong
_BNGetMappedMediumLevelILExprIndex.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMappedMediumLevelILExprIndex(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int
) -> int:
return _BNGetMappedMediumLevelILExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetMappedMediumLevelILInstructionIndex
_BNGetMappedMediumLevelILInstructionIndex = core.BNGetMappedMediumLevelILInstructionIndex
_BNGetMappedMediumLevelILInstructionIndex.restype = ctypes.c_ulonglong
_BNGetMappedMediumLevelILInstructionIndex.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMappedMediumLevelILInstructionIndex(
func: ctypes.POINTER(BNLowLevelILFunction),
instr: int
) -> int:
return _BNGetMappedMediumLevelILInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetMaxFunctionSizeForAnalysis
_BNGetMaxFunctionSizeForAnalysis = core.BNGetMaxFunctionSizeForAnalysis
_BNGetMaxFunctionSizeForAnalysis.restype = ctypes.c_ulonglong
_BNGetMaxFunctionSizeForAnalysis.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetMaxFunctionSizeForAnalysis(
view: ctypes.POINTER(BNBinaryView)
) -> int:
return _BNGetMaxFunctionSizeForAnalysis(view)
# -------------------------------------------------------
# _BNGetMediumLevelILAliasedVariables
_BNGetMediumLevelILAliasedVariables = core.BNGetMediumLevelILAliasedVariables
_BNGetMediumLevelILAliasedVariables.restype = ctypes.POINTER(BNVariable)
_BNGetMediumLevelILAliasedVariables.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILAliasedVariables(
func: ctypes.POINTER(BNMediumLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariable)]:
result = _BNGetMediumLevelILAliasedVariables(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILBasicBlockForInstruction
_BNGetMediumLevelILBasicBlockForInstruction = core.BNGetMediumLevelILBasicBlockForInstruction
_BNGetMediumLevelILBasicBlockForInstruction.restype = ctypes.POINTER(BNBasicBlock)
_BNGetMediumLevelILBasicBlockForInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILBasicBlockForInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
i: int
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetMediumLevelILBasicBlockForInstruction(func, i)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILBasicBlockList
_BNGetMediumLevelILBasicBlockList = core.BNGetMediumLevelILBasicBlockList
_BNGetMediumLevelILBasicBlockList.restype = ctypes.POINTER(ctypes.POINTER(BNBasicBlock))
_BNGetMediumLevelILBasicBlockList.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILBasicBlockList(
func: ctypes.POINTER(BNMediumLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBasicBlock))]:
result = _BNGetMediumLevelILBasicBlockList(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILBranchDependence
_BNGetMediumLevelILBranchDependence = core.BNGetMediumLevelILBranchDependence
_BNGetMediumLevelILBranchDependence.restype = ILBranchDependenceEnum
_BNGetMediumLevelILBranchDependence.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILBranchDependence(
func: ctypes.POINTER(BNMediumLevelILFunction),
curInstr: int,
branchInstr: int
) -> ILBranchDependence:
return _BNGetMediumLevelILBranchDependence(func, curInstr, branchInstr)
# -------------------------------------------------------
# _BNGetMediumLevelILByIndex
_BNGetMediumLevelILByIndex = core.BNGetMediumLevelILByIndex
_BNGetMediumLevelILByIndex.restype = BNMediumLevelILInstruction
_BNGetMediumLevelILByIndex.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILByIndex(
func: ctypes.POINTER(BNMediumLevelILFunction),
i: int
) -> BNMediumLevelILInstruction:
return _BNGetMediumLevelILByIndex(func, i)
# -------------------------------------------------------
# _BNGetMediumLevelILExprCount
_BNGetMediumLevelILExprCount = core.BNGetMediumLevelILExprCount
_BNGetMediumLevelILExprCount.restype = ctypes.c_ulonglong
_BNGetMediumLevelILExprCount.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILExprCount(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> int:
return _BNGetMediumLevelILExprCount(func)
# -------------------------------------------------------
# _BNGetMediumLevelILExprIndex
_BNGetMediumLevelILExprIndex = core.BNGetMediumLevelILExprIndex
_BNGetMediumLevelILExprIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILExprIndex.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILExprIndex(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int
) -> int:
return _BNGetMediumLevelILExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetMediumLevelILExprIndexFromHighLevelIL
_BNGetMediumLevelILExprIndexFromHighLevelIL = core.BNGetMediumLevelILExprIndexFromHighLevelIL
_BNGetMediumLevelILExprIndexFromHighLevelIL.restype = ctypes.c_ulonglong
_BNGetMediumLevelILExprIndexFromHighLevelIL.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILExprIndexFromHighLevelIL(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int
) -> int:
return _BNGetMediumLevelILExprIndexFromHighLevelIL(func, expr)
# -------------------------------------------------------
# _BNGetMediumLevelILExprIndexes
_BNGetMediumLevelILExprIndexes = core.BNGetMediumLevelILExprIndexes
_BNGetMediumLevelILExprIndexes.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILExprIndexes.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILExprIndexes(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetMediumLevelILExprIndexes(func, expr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILExprIndexesFromHighLevelIL
_BNGetMediumLevelILExprIndexesFromHighLevelIL = core.BNGetMediumLevelILExprIndexesFromHighLevelIL
_BNGetMediumLevelILExprIndexesFromHighLevelIL.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILExprIndexesFromHighLevelIL.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILExprIndexesFromHighLevelIL(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetMediumLevelILExprIndexesFromHighLevelIL(func, expr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILExprText
_BNGetMediumLevelILExprText = core.BNGetMediumLevelILExprText
_BNGetMediumLevelILExprText.restype = ctypes.c_bool
_BNGetMediumLevelILExprText.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILExprText(
func: ctypes.POINTER(BNMediumLevelILFunction),
arch: ctypes.POINTER(BNArchitecture),
i: int,
tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
count: ctypes.POINTER(ctypes.c_ulonglong),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> bool:
return _BNGetMediumLevelILExprText(func, arch, i, tokens, count, settings)
# -------------------------------------------------------
# _BNGetMediumLevelILExprType
_BNGetMediumLevelILExprType = core.BNGetMediumLevelILExprType
_BNGetMediumLevelILExprType.restype = BNTypeWithConfidence
_BNGetMediumLevelILExprType.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILExprType(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int
) -> BNTypeWithConfidence:
return _BNGetMediumLevelILExprType(func, expr)
# -------------------------------------------------------
# _BNGetMediumLevelILExprValue
_BNGetMediumLevelILExprValue = core.BNGetMediumLevelILExprValue
_BNGetMediumLevelILExprValue.restype = BNRegisterValue
_BNGetMediumLevelILExprValue.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILExprValue(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int
) -> BNRegisterValue:
return _BNGetMediumLevelILExprValue(func, expr)
# -------------------------------------------------------
# _BNGetMediumLevelILFlagValueAfterInstruction
_BNGetMediumLevelILFlagValueAfterInstruction = core.BNGetMediumLevelILFlagValueAfterInstruction
_BNGetMediumLevelILFlagValueAfterInstruction.restype = BNRegisterValue
_BNGetMediumLevelILFlagValueAfterInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILFlagValueAfterInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
flag: int,
instr: int
) -> BNRegisterValue:
return _BNGetMediumLevelILFlagValueAfterInstruction(func, flag, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILFlagValueAtInstruction
_BNGetMediumLevelILFlagValueAtInstruction = core.BNGetMediumLevelILFlagValueAtInstruction
_BNGetMediumLevelILFlagValueAtInstruction.restype = BNRegisterValue
_BNGetMediumLevelILFlagValueAtInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILFlagValueAtInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
flag: int,
instr: int
) -> BNRegisterValue:
return _BNGetMediumLevelILFlagValueAtInstruction(func, flag, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILForHighLevelILFunction
_BNGetMediumLevelILForHighLevelILFunction = core.BNGetMediumLevelILForHighLevelILFunction
_BNGetMediumLevelILForHighLevelILFunction.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMediumLevelILForHighLevelILFunction.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILForHighLevelILFunction(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetMediumLevelILForHighLevelILFunction(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILForLowLevelIL
_BNGetMediumLevelILForLowLevelIL = core.BNGetMediumLevelILForLowLevelIL
_BNGetMediumLevelILForLowLevelIL.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMediumLevelILForLowLevelIL.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILForLowLevelIL(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetMediumLevelILForLowLevelIL(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILIndexForInstruction
_BNGetMediumLevelILIndexForInstruction = core.BNGetMediumLevelILIndexForInstruction
_BNGetMediumLevelILIndexForInstruction.restype = ctypes.c_ulonglong
_BNGetMediumLevelILIndexForInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILIndexForInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
i: int
) -> int:
return _BNGetMediumLevelILIndexForInstruction(func, i)
# -------------------------------------------------------
# _BNGetMediumLevelILInstructionCount
_BNGetMediumLevelILInstructionCount = core.BNGetMediumLevelILInstructionCount
_BNGetMediumLevelILInstructionCount.restype = ctypes.c_ulonglong
_BNGetMediumLevelILInstructionCount.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILInstructionCount(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> int:
return _BNGetMediumLevelILInstructionCount(func)
# -------------------------------------------------------
# _BNGetMediumLevelILInstructionForExpr
_BNGetMediumLevelILInstructionForExpr = core.BNGetMediumLevelILInstructionForExpr
_BNGetMediumLevelILInstructionForExpr.restype = ctypes.c_ulonglong
_BNGetMediumLevelILInstructionForExpr.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILInstructionForExpr(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int
) -> int:
return _BNGetMediumLevelILInstructionForExpr(func, expr)
# -------------------------------------------------------
# _BNGetMediumLevelILInstructionIndex
_BNGetMediumLevelILInstructionIndex = core.BNGetMediumLevelILInstructionIndex
_BNGetMediumLevelILInstructionIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILInstructionIndex.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILInstructionIndex(
func: ctypes.POINTER(BNLowLevelILFunction),
instr: int
) -> int:
return _BNGetMediumLevelILInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILInstructionText
_BNGetMediumLevelILInstructionText = core.BNGetMediumLevelILInstructionText
_BNGetMediumLevelILInstructionText.restype = ctypes.c_bool
_BNGetMediumLevelILInstructionText.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILInstructionText(
il: ctypes.POINTER(BNMediumLevelILFunction),
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
i: int,
tokens: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
count: ctypes.POINTER(ctypes.c_ulonglong),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> bool:
return _BNGetMediumLevelILInstructionText(il, func, arch, i, tokens, count, settings)
# -------------------------------------------------------
# _BNGetMediumLevelILLiveInstructionsForVariable
_BNGetMediumLevelILLiveInstructionsForVariable = core.BNGetMediumLevelILLiveInstructionsForVariable
_BNGetMediumLevelILLiveInstructionsForVariable.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILLiveInstructionsForVariable.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_bool,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILLiveInstructionsForVariable(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
includeLastUse: bool,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetMediumLevelILLiveInstructionsForVariable(func, var, includeLastUse, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILNonSSAExprIndex
_BNGetMediumLevelILNonSSAExprIndex = core.BNGetMediumLevelILNonSSAExprIndex
_BNGetMediumLevelILNonSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILNonSSAExprIndex.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILNonSSAExprIndex(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int
) -> int:
return _BNGetMediumLevelILNonSSAExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetMediumLevelILNonSSAForm
_BNGetMediumLevelILNonSSAForm = core.BNGetMediumLevelILNonSSAForm
_BNGetMediumLevelILNonSSAForm.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMediumLevelILNonSSAForm.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILNonSSAForm(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetMediumLevelILNonSSAForm(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILNonSSAInstructionIndex
_BNGetMediumLevelILNonSSAInstructionIndex = core.BNGetMediumLevelILNonSSAInstructionIndex
_BNGetMediumLevelILNonSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILNonSSAInstructionIndex.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILNonSSAInstructionIndex(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int
) -> int:
return _BNGetMediumLevelILNonSSAInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILOwnerFunction
_BNGetMediumLevelILOwnerFunction = core.BNGetMediumLevelILOwnerFunction
_BNGetMediumLevelILOwnerFunction.restype = ctypes.POINTER(BNFunction)
_BNGetMediumLevelILOwnerFunction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILOwnerFunction(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetMediumLevelILOwnerFunction(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILPossibleExprValues
_BNGetMediumLevelILPossibleExprValues = core.BNGetMediumLevelILPossibleExprValues
_BNGetMediumLevelILPossibleExprValues.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleExprValues.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleExprValues(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetMediumLevelILPossibleExprValues(func, expr, options, optionCount)
# -------------------------------------------------------
# _BNGetMediumLevelILPossibleFlagValuesAfterInstruction
_BNGetMediumLevelILPossibleFlagValuesAfterInstruction = core.BNGetMediumLevelILPossibleFlagValuesAfterInstruction
_BNGetMediumLevelILPossibleFlagValuesAfterInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleFlagValuesAfterInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleFlagValuesAfterInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
flag: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetMediumLevelILPossibleFlagValuesAfterInstruction(func, flag, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetMediumLevelILPossibleFlagValuesAtInstruction
_BNGetMediumLevelILPossibleFlagValuesAtInstruction = core.BNGetMediumLevelILPossibleFlagValuesAtInstruction
_BNGetMediumLevelILPossibleFlagValuesAtInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleFlagValuesAtInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleFlagValuesAtInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
flag: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetMediumLevelILPossibleFlagValuesAtInstruction(func, flag, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetMediumLevelILPossibleRegisterValuesAfterInstruction
_BNGetMediumLevelILPossibleRegisterValuesAfterInstruction = core.BNGetMediumLevelILPossibleRegisterValuesAfterInstruction
_BNGetMediumLevelILPossibleRegisterValuesAfterInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleRegisterValuesAfterInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleRegisterValuesAfterInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
reg: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetMediumLevelILPossibleRegisterValuesAfterInstruction(func, reg, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetMediumLevelILPossibleRegisterValuesAtInstruction
_BNGetMediumLevelILPossibleRegisterValuesAtInstruction = core.BNGetMediumLevelILPossibleRegisterValuesAtInstruction
_BNGetMediumLevelILPossibleRegisterValuesAtInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleRegisterValuesAtInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleRegisterValuesAtInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
reg: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetMediumLevelILPossibleRegisterValuesAtInstruction(func, reg, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetMediumLevelILPossibleSSAVarValues
_BNGetMediumLevelILPossibleSSAVarValues = core.BNGetMediumLevelILPossibleSSAVarValues
_BNGetMediumLevelILPossibleSSAVarValues.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleSSAVarValues.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleSSAVarValues(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
version: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetMediumLevelILPossibleSSAVarValues(func, var, version, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetMediumLevelILPossibleStackContentsAfterInstruction
_BNGetMediumLevelILPossibleStackContentsAfterInstruction = core.BNGetMediumLevelILPossibleStackContentsAfterInstruction
_BNGetMediumLevelILPossibleStackContentsAfterInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleStackContentsAfterInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_longlong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleStackContentsAfterInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
offset: int,
len: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetMediumLevelILPossibleStackContentsAfterInstruction(func, offset, len, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetMediumLevelILPossibleStackContentsAtInstruction
_BNGetMediumLevelILPossibleStackContentsAtInstruction = core.BNGetMediumLevelILPossibleStackContentsAtInstruction
_BNGetMediumLevelILPossibleStackContentsAtInstruction.restype = BNPossibleValueSet
_BNGetMediumLevelILPossibleStackContentsAtInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_longlong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(DataFlowQueryOptionEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILPossibleStackContentsAtInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
offset: int,
len: int,
instr: int,
options: ctypes.POINTER(DataFlowQueryOptionEnum),
optionCount: int
) -> BNPossibleValueSet:
return _BNGetMediumLevelILPossibleStackContentsAtInstruction(func, offset, len, instr, options, optionCount)
# -------------------------------------------------------
# _BNGetMediumLevelILRegisterValueAfterInstruction
_BNGetMediumLevelILRegisterValueAfterInstruction = core.BNGetMediumLevelILRegisterValueAfterInstruction
_BNGetMediumLevelILRegisterValueAfterInstruction.restype = BNRegisterValue
_BNGetMediumLevelILRegisterValueAfterInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILRegisterValueAfterInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
reg: int,
instr: int
) -> BNRegisterValue:
return _BNGetMediumLevelILRegisterValueAfterInstruction(func, reg, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILRegisterValueAtInstruction
_BNGetMediumLevelILRegisterValueAtInstruction = core.BNGetMediumLevelILRegisterValueAtInstruction
_BNGetMediumLevelILRegisterValueAtInstruction.restype = BNRegisterValue
_BNGetMediumLevelILRegisterValueAtInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILRegisterValueAtInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
reg: int,
instr: int
) -> BNRegisterValue:
return _BNGetMediumLevelILRegisterValueAtInstruction(func, reg, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILSSAExprIndex
_BNGetMediumLevelILSSAExprIndex = core.BNGetMediumLevelILSSAExprIndex
_BNGetMediumLevelILSSAExprIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAExprIndex.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAExprIndex(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int
) -> int:
return _BNGetMediumLevelILSSAExprIndex(func, expr)
# -------------------------------------------------------
# _BNGetMediumLevelILSSAForm
_BNGetMediumLevelILSSAForm = core.BNGetMediumLevelILSSAForm
_BNGetMediumLevelILSSAForm.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNGetMediumLevelILSSAForm.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAForm(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNGetMediumLevelILSSAForm(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILSSAInstructionIndex
_BNGetMediumLevelILSSAInstructionIndex = core.BNGetMediumLevelILSSAInstructionIndex
_BNGetMediumLevelILSSAInstructionIndex.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAInstructionIndex.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAInstructionIndex(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int
) -> int:
return _BNGetMediumLevelILSSAInstructionIndex(func, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILSSAMemoryDefinition
_BNGetMediumLevelILSSAMemoryDefinition = core.BNGetMediumLevelILSSAMemoryDefinition
_BNGetMediumLevelILSSAMemoryDefinition.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAMemoryDefinition.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAMemoryDefinition(
func: ctypes.POINTER(BNMediumLevelILFunction),
version: int
) -> int:
return _BNGetMediumLevelILSSAMemoryDefinition(func, version)
# -------------------------------------------------------
# _BNGetMediumLevelILSSAMemoryUses
_BNGetMediumLevelILSSAMemoryUses = core.BNGetMediumLevelILSSAMemoryUses
_BNGetMediumLevelILSSAMemoryUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILSSAMemoryUses.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAMemoryUses(
func: ctypes.POINTER(BNMediumLevelILFunction),
version: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetMediumLevelILSSAMemoryUses(func, version, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILSSAMemoryVersionAtILInstruction
_BNGetMediumLevelILSSAMemoryVersionAtILInstruction = core.BNGetMediumLevelILSSAMemoryVersionAtILInstruction
_BNGetMediumLevelILSSAMemoryVersionAtILInstruction.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAMemoryVersionAtILInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAMemoryVersionAtILInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int
) -> int:
return _BNGetMediumLevelILSSAMemoryVersionAtILInstruction(func, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILSSAVarDefinition
_BNGetMediumLevelILSSAVarDefinition = core.BNGetMediumLevelILSSAVarDefinition
_BNGetMediumLevelILSSAVarDefinition.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAVarDefinition.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAVarDefinition(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
version: int
) -> int:
return _BNGetMediumLevelILSSAVarDefinition(func, var, version)
# -------------------------------------------------------
# _BNGetMediumLevelILSSAVarUses
_BNGetMediumLevelILSSAVarUses = core.BNGetMediumLevelILSSAVarUses
_BNGetMediumLevelILSSAVarUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILSSAVarUses.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAVarUses(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
version: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetMediumLevelILSSAVarUses(func, var, version, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILSSAVarValue
_BNGetMediumLevelILSSAVarValue = core.BNGetMediumLevelILSSAVarValue
_BNGetMediumLevelILSSAVarValue.restype = BNRegisterValue
_BNGetMediumLevelILSSAVarValue.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAVarValue(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
version: int
) -> BNRegisterValue:
return _BNGetMediumLevelILSSAVarValue(func, var, version)
# -------------------------------------------------------
# _BNGetMediumLevelILSSAVarVersionAtILInstruction
_BNGetMediumLevelILSSAVarVersionAtILInstruction = core.BNGetMediumLevelILSSAVarVersionAtILInstruction
_BNGetMediumLevelILSSAVarVersionAtILInstruction.restype = ctypes.c_ulonglong
_BNGetMediumLevelILSSAVarVersionAtILInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILSSAVarVersionAtILInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
instr: int
) -> int:
return _BNGetMediumLevelILSSAVarVersionAtILInstruction(func, var, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILStackContentsAfterInstruction
_BNGetMediumLevelILStackContentsAfterInstruction = core.BNGetMediumLevelILStackContentsAfterInstruction
_BNGetMediumLevelILStackContentsAfterInstruction.restype = BNRegisterValue
_BNGetMediumLevelILStackContentsAfterInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_longlong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILStackContentsAfterInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
offset: int,
len: int,
instr: int
) -> BNRegisterValue:
return _BNGetMediumLevelILStackContentsAfterInstruction(func, offset, len, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILStackContentsAtInstruction
_BNGetMediumLevelILStackContentsAtInstruction = core.BNGetMediumLevelILStackContentsAtInstruction
_BNGetMediumLevelILStackContentsAtInstruction.restype = BNRegisterValue
_BNGetMediumLevelILStackContentsAtInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_longlong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILStackContentsAtInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
offset: int,
len: int,
instr: int
) -> BNRegisterValue:
return _BNGetMediumLevelILStackContentsAtInstruction(func, offset, len, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILVariableDefinitions
_BNGetMediumLevelILVariableDefinitions = core.BNGetMediumLevelILVariableDefinitions
_BNGetMediumLevelILVariableDefinitions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILVariableDefinitions.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableDefinitions(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetMediumLevelILVariableDefinitions(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILVariableForFlagAtInstruction
_BNGetMediumLevelILVariableForFlagAtInstruction = core.BNGetMediumLevelILVariableForFlagAtInstruction
_BNGetMediumLevelILVariableForFlagAtInstruction.restype = BNVariable
_BNGetMediumLevelILVariableForFlagAtInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableForFlagAtInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
flag: int,
instr: int
) -> BNVariable:
return _BNGetMediumLevelILVariableForFlagAtInstruction(func, flag, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILVariableForRegisterAtInstruction
_BNGetMediumLevelILVariableForRegisterAtInstruction = core.BNGetMediumLevelILVariableForRegisterAtInstruction
_BNGetMediumLevelILVariableForRegisterAtInstruction.restype = BNVariable
_BNGetMediumLevelILVariableForRegisterAtInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_uint,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableForRegisterAtInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
reg: int,
instr: int
) -> BNVariable:
return _BNGetMediumLevelILVariableForRegisterAtInstruction(func, reg, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILVariableForStackLocationAtInstruction
_BNGetMediumLevelILVariableForStackLocationAtInstruction = core.BNGetMediumLevelILVariableForStackLocationAtInstruction
_BNGetMediumLevelILVariableForStackLocationAtInstruction.restype = BNVariable
_BNGetMediumLevelILVariableForStackLocationAtInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_longlong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableForStackLocationAtInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
offset: int,
instr: int
) -> BNVariable:
return _BNGetMediumLevelILVariableForStackLocationAtInstruction(func, offset, instr)
# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferences
_BNGetMediumLevelILVariableReferences = core.BNGetMediumLevelILVariableReferences
_BNGetMediumLevelILVariableReferences.restype = ctypes.POINTER(BNILReferenceSource)
_BNGetMediumLevelILVariableReferences.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferences(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNILReferenceSource)]:
result = _BNGetMediumLevelILVariableReferences(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesFrom
_BNGetMediumLevelILVariableReferencesFrom = core.BNGetMediumLevelILVariableReferencesFrom
_BNGetMediumLevelILVariableReferencesFrom.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetMediumLevelILVariableReferencesFrom.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesFrom(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
address: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
result = _BNGetMediumLevelILVariableReferencesFrom(func, arch, address, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesFromIfAvailable
_BNGetMediumLevelILVariableReferencesFromIfAvailable = core.BNGetMediumLevelILVariableReferencesFromIfAvailable
_BNGetMediumLevelILVariableReferencesFromIfAvailable.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetMediumLevelILVariableReferencesFromIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesFromIfAvailable(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
address: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
result = _BNGetMediumLevelILVariableReferencesFromIfAvailable(func, arch, address, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesIfAvailable
_BNGetMediumLevelILVariableReferencesIfAvailable = core.BNGetMediumLevelILVariableReferencesIfAvailable
_BNGetMediumLevelILVariableReferencesIfAvailable.restype = ctypes.POINTER(BNILReferenceSource)
_BNGetMediumLevelILVariableReferencesIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesIfAvailable(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNILReferenceSource)]:
result = _BNGetMediumLevelILVariableReferencesIfAvailable(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesInRange
_BNGetMediumLevelILVariableReferencesInRange = core.BNGetMediumLevelILVariableReferencesInRange
_BNGetMediumLevelILVariableReferencesInRange.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetMediumLevelILVariableReferencesInRange.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesInRange(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
address: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
result = _BNGetMediumLevelILVariableReferencesInRange(func, arch, address, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILVariableReferencesInRangeIfAvailable
_BNGetMediumLevelILVariableReferencesInRangeIfAvailable = core.BNGetMediumLevelILVariableReferencesInRangeIfAvailable
_BNGetMediumLevelILVariableReferencesInRangeIfAvailable.restype = ctypes.POINTER(BNVariableReferenceSource)
_BNGetMediumLevelILVariableReferencesInRangeIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableReferencesInRangeIfAvailable(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
address: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableReferenceSource)]:
result = _BNGetMediumLevelILVariableReferencesInRangeIfAvailable(func, arch, address, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILVariableSSAVersions
_BNGetMediumLevelILVariableSSAVersions = core.BNGetMediumLevelILVariableSSAVersions
_BNGetMediumLevelILVariableSSAVersions.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILVariableSSAVersions.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableSSAVersions(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetMediumLevelILVariableSSAVersions(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILVariableUses
_BNGetMediumLevelILVariableUses = core.BNGetMediumLevelILVariableUses
_BNGetMediumLevelILVariableUses.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetMediumLevelILVariableUses.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariableUses(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetMediumLevelILVariableUses(func, var, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMediumLevelILVariables
_BNGetMediumLevelILVariables = core.BNGetMediumLevelILVariables
_BNGetMediumLevelILVariables.restype = ctypes.POINTER(BNVariable)
_BNGetMediumLevelILVariables.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMediumLevelILVariables(
func: ctypes.POINTER(BNMediumLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariable)]:
result = _BNGetMediumLevelILVariables(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMemberIncludingInheritedAtOffset
_BNGetMemberIncludingInheritedAtOffset = core.BNGetMemberIncludingInheritedAtOffset
_BNGetMemberIncludingInheritedAtOffset.restype = ctypes.POINTER(BNInheritedStructureMember)
_BNGetMemberIncludingInheritedAtOffset.argtypes = [
ctypes.POINTER(BNStructure),
ctypes.POINTER(BNBinaryView),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNGetMemberIncludingInheritedAtOffset(
s: ctypes.POINTER(BNStructure),
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> Optional[ctypes.POINTER(BNInheritedStructureMember)]:
result = _BNGetMemberIncludingInheritedAtOffset(s, view, offset)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMemoryUsageInfo
_BNGetMemoryUsageInfo = core.BNGetMemoryUsageInfo
_BNGetMemoryUsageInfo.restype = ctypes.POINTER(BNMemoryUsageInfo)
_BNGetMemoryUsageInfo.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMemoryUsageInfo(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNMemoryUsageInfo)]:
result = _BNGetMemoryUsageInfo(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMergedVariables
_BNGetMergedVariables = core.BNGetMergedVariables
_BNGetMergedVariables.restype = ctypes.POINTER(BNMergedVariable)
_BNGetMergedVariables.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetMergedVariables(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNMergedVariable)]:
result = _BNGetMergedVariables(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetMinimumCoreABIVersion
_BNGetMinimumCoreABIVersion = core.BNGetMinimumCoreABIVersion
_BNGetMinimumCoreABIVersion.restype = ctypes.c_uint
_BNGetMinimumCoreABIVersion.argtypes = [
]
# noinspection PyPep8Naming
def BNGetMinimumCoreABIVersion(
) -> int:
return _BNGetMinimumCoreABIVersion()
# -------------------------------------------------------
# _BNGetModification
_BNGetModification = core.BNGetModification
_BNGetModification.restype = ModificationStatusEnum
_BNGetModification.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetModification(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> ModificationStatus:
return _BNGetModification(view, offset)
# -------------------------------------------------------
# _BNGetModificationArray
_BNGetModificationArray = core.BNGetModificationArray
_BNGetModificationArray.restype = ctypes.c_ulonglong
_BNGetModificationArray.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ModificationStatusEnum),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetModificationArray(
view: ctypes.POINTER(BNBinaryView),
offset: int,
result: ctypes.POINTER(ModificationStatusEnum),
len: int
) -> int:
return _BNGetModificationArray(view, offset, result, len)
# -------------------------------------------------------
# _BNGetModifiedArchitectureRegistersOnWrite
_BNGetModifiedArchitectureRegistersOnWrite = core.BNGetModifiedArchitectureRegistersOnWrite
_BNGetModifiedArchitectureRegistersOnWrite.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetModifiedArchitectureRegistersOnWrite.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetModifiedArchitectureRegistersOnWrite(
arch: ctypes.POINTER(BNArchitecture),
reg: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetModifiedArchitectureRegistersOnWrite(arch, reg, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetNameSpaces
_BNGetNameSpaces = core.BNGetNameSpaces
_BNGetNameSpaces.restype = ctypes.POINTER(BNNameSpace)
_BNGetNameSpaces.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetNameSpaces(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNNameSpace)]:
result = _BNGetNameSpaces(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetNativeTypeParserArchitecture
_BNGetNativeTypeParserArchitecture = core.BNGetNativeTypeParserArchitecture
_BNGetNativeTypeParserArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetNativeTypeParserArchitecture.argtypes = [
]
# noinspection PyPep8Naming
def BNGetNativeTypeParserArchitecture(
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetNativeTypeParserArchitecture()
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetNewAutoFunctionAnalysisSuppressed
_BNGetNewAutoFunctionAnalysisSuppressed = core.BNGetNewAutoFunctionAnalysisSuppressed
_BNGetNewAutoFunctionAnalysisSuppressed.restype = ctypes.c_bool
_BNGetNewAutoFunctionAnalysisSuppressed.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetNewAutoFunctionAnalysisSuppressed(
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNGetNewAutoFunctionAnalysisSuppressed(view)
# -------------------------------------------------------
# _BNGetNextBasicBlockStartAfterAddress
_BNGetNextBasicBlockStartAfterAddress = core.BNGetNextBasicBlockStartAfterAddress
_BNGetNextBasicBlockStartAfterAddress.restype = ctypes.c_ulonglong
_BNGetNextBasicBlockStartAfterAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetNextBasicBlockStartAfterAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> int:
return _BNGetNextBasicBlockStartAfterAddress(view, addr)
# -------------------------------------------------------
# _BNGetNextDataAfterAddress
_BNGetNextDataAfterAddress = core.BNGetNextDataAfterAddress
_BNGetNextDataAfterAddress.restype = ctypes.c_ulonglong
_BNGetNextDataAfterAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetNextDataAfterAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> int:
return _BNGetNextDataAfterAddress(view, addr)
# -------------------------------------------------------
# _BNGetNextDataVariableStartAfterAddress
_BNGetNextDataVariableStartAfterAddress = core.BNGetNextDataVariableStartAfterAddress
_BNGetNextDataVariableStartAfterAddress.restype = ctypes.c_ulonglong
_BNGetNextDataVariableStartAfterAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetNextDataVariableStartAfterAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> int:
return _BNGetNextDataVariableStartAfterAddress(view, addr)
# -------------------------------------------------------
# _BNGetNextFunctionStartAfterAddress
_BNGetNextFunctionStartAfterAddress = core.BNGetNextFunctionStartAfterAddress
_BNGetNextFunctionStartAfterAddress.restype = ctypes.c_ulonglong
_BNGetNextFunctionStartAfterAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetNextFunctionStartAfterAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> int:
return _BNGetNextFunctionStartAfterAddress(view, addr)
# -------------------------------------------------------
# _BNGetNextLinearViewObjectChild
_BNGetNextLinearViewObjectChild = core.BNGetNextLinearViewObjectChild
_BNGetNextLinearViewObjectChild.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetNextLinearViewObjectChild.argtypes = [
ctypes.POINTER(BNLinearViewObject),
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNGetNextLinearViewObjectChild(
parent: ctypes.POINTER(BNLinearViewObject),
child: ctypes.POINTER(BNLinearViewObject)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNGetNextLinearViewObjectChild(parent, child)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetNextValidOffset
_BNGetNextValidOffset = core.BNGetNextValidOffset
_BNGetNextValidOffset.restype = ctypes.c_ulonglong
_BNGetNextValidOffset.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetNextValidOffset(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> int:
return _BNGetNextValidOffset(view, offset)
# -------------------------------------------------------
# _BNGetOpenFileNameInput
_BNGetOpenFileNameInput = core.BNGetOpenFileNameInput
_BNGetOpenFileNameInput.restype = ctypes.c_bool
_BNGetOpenFileNameInput.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetOpenFileNameInput(
result: ctypes.POINTER(ctypes.c_char_p),
prompt: Optional[str],
ext: Optional[str]
) -> bool:
return _BNGetOpenFileNameInput(result, cstr(prompt), cstr(ext))
# -------------------------------------------------------
# _BNGetOpenProjects
_BNGetOpenProjects = core.BNGetOpenProjects
_BNGetOpenProjects.restype = ctypes.POINTER(ctypes.POINTER(BNProject))
_BNGetOpenProjects.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetOpenProjects(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNProject))]:
result = _BNGetOpenProjects(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetOriginalBase
_BNGetOriginalBase = core.BNGetOriginalBase
_BNGetOriginalBase.restype = ctypes.c_ulonglong
_BNGetOriginalBase.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetOriginalBase(
view: ctypes.POINTER(BNBinaryView)
) -> int:
return _BNGetOriginalBase(view)
# -------------------------------------------------------
# _BNGetOriginalFilename
_BNGetOriginalFilename = core.BNGetOriginalFilename
_BNGetOriginalFilename.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetOriginalFilename.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetOriginalFilename(
file: ctypes.POINTER(BNFileMetadata)
) -> Optional[Optional[str]]:
result = _BNGetOriginalFilename(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetOutgoingDirectTypeReferences
_BNGetOutgoingDirectTypeReferences = core.BNGetOutgoingDirectTypeReferences
_BNGetOutgoingDirectTypeReferences.restype = ctypes.POINTER(BNQualifiedName)
_BNGetOutgoingDirectTypeReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetOutgoingDirectTypeReferences(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedName)]:
result = _BNGetOutgoingDirectTypeReferences(view, type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetOutgoingRecursiveTypeReferences
_BNGetOutgoingRecursiveTypeReferences = core.BNGetOutgoingRecursiveTypeReferences
_BNGetOutgoingRecursiveTypeReferences.restype = ctypes.POINTER(BNQualifiedName)
_BNGetOutgoingRecursiveTypeReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetOutgoingRecursiveTypeReferences(
view: ctypes.POINTER(BNBinaryView),
types: ctypes.POINTER(BNQualifiedName),
typeCount: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedName)]:
result = _BNGetOutgoingRecursiveTypeReferences(view, types, typeCount, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetParameterOrderingForVariables
_BNGetParameterOrderingForVariables = core.BNGetParameterOrderingForVariables
_BNGetParameterOrderingForVariables.restype = ctypes.POINTER(BNVariable)
_BNGetParameterOrderingForVariables.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetParameterOrderingForVariables(
cc: ctypes.POINTER(BNCallingConvention),
paramVars: ctypes.POINTER(BNVariable),
paramTypes: ctypes.POINTER(ctypes.POINTER(BNType)),
paramCount: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariable)]:
result = _BNGetParameterOrderingForVariables(cc, paramVars, paramTypes, paramCount, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetParameterValueAtInstruction
_BNGetParameterValueAtInstruction = core.BNGetParameterValueAtInstruction
_BNGetParameterValueAtInstruction.restype = BNRegisterValue
_BNGetParameterValueAtInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNType),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetParameterValueAtInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
functionType: ctypes.POINTER(BNType),
i: int
) -> BNRegisterValue:
return _BNGetParameterValueAtInstruction(func, arch, addr, functionType, i)
# -------------------------------------------------------
# _BNGetParameterValueAtLowLevelILInstruction
_BNGetParameterValueAtLowLevelILInstruction = core.BNGetParameterValueAtLowLevelILInstruction
_BNGetParameterValueAtLowLevelILInstruction.restype = BNRegisterValue
_BNGetParameterValueAtLowLevelILInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
ctypes.POINTER(BNType),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetParameterValueAtLowLevelILInstruction(
func: ctypes.POINTER(BNFunction),
instr: int,
functionType: ctypes.POINTER(BNType),
i: int
) -> BNRegisterValue:
return _BNGetParameterValueAtLowLevelILInstruction(func, instr, functionType, i)
# -------------------------------------------------------
# _BNGetParameterVariableForIncomingVariable
_BNGetParameterVariableForIncomingVariable = core.BNGetParameterVariableForIncomingVariable
_BNGetParameterVariableForIncomingVariable.restype = BNVariable
_BNGetParameterVariableForIncomingVariable.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(BNVariable),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetParameterVariableForIncomingVariable(
cc: ctypes.POINTER(BNCallingConvention),
var: ctypes.POINTER(BNVariable),
func: ctypes.POINTER(BNFunction)
) -> BNVariable:
return _BNGetParameterVariableForIncomingVariable(cc, var, func)
# -------------------------------------------------------
# _BNGetParametersForAnalysis
_BNGetParametersForAnalysis = core.BNGetParametersForAnalysis
_BNGetParametersForAnalysis.restype = BNAnalysisParameters
_BNGetParametersForAnalysis.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetParametersForAnalysis(
view: ctypes.POINTER(BNBinaryView)
) -> BNAnalysisParameters:
return _BNGetParametersForAnalysis(view)
# -------------------------------------------------------
# _BNGetParentPath
_BNGetParentPath = core.BNGetParentPath
_BNGetParentPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetParentPath.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetParentPath(
path: Optional[str]
) -> Optional[Optional[str]]:
result = _BNGetParentPath(cstr(path))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetParentView
_BNGetParentView = core.BNGetParentView
_BNGetParentView.restype = ctypes.POINTER(BNBinaryView)
_BNGetParentView.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetParentView(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNGetParentView(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPathRelativeToBundledPluginDirectory
_BNGetPathRelativeToBundledPluginDirectory = core.BNGetPathRelativeToBundledPluginDirectory
_BNGetPathRelativeToBundledPluginDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPathRelativeToBundledPluginDirectory.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetPathRelativeToBundledPluginDirectory(
path: Optional[str]
) -> Optional[Optional[str]]:
result = _BNGetPathRelativeToBundledPluginDirectory(cstr(path))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetPathRelativeToUserDirectory
_BNGetPathRelativeToUserDirectory = core.BNGetPathRelativeToUserDirectory
_BNGetPathRelativeToUserDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPathRelativeToUserDirectory.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetPathRelativeToUserDirectory(
path: Optional[str]
) -> Optional[Optional[str]]:
result = _BNGetPathRelativeToUserDirectory(cstr(path))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetPathRelativeToUserPluginDirectory
_BNGetPathRelativeToUserPluginDirectory = core.BNGetPathRelativeToUserPluginDirectory
_BNGetPathRelativeToUserPluginDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPathRelativeToUserPluginDirectory.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetPathRelativeToUserPluginDirectory(
path: Optional[str]
) -> Optional[Optional[str]]:
result = _BNGetPathRelativeToUserPluginDirectory(cstr(path))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetPlatformArchitecture
_BNGetPlatformArchitecture = core.BNGetPlatformArchitecture
_BNGetPlatformArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetPlatformArchitecture.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetPlatformArchitecture(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetPlatformArchitecture(platform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformByName
_BNGetPlatformByName = core.BNGetPlatformByName
_BNGetPlatformByName.restype = ctypes.POINTER(BNPlatform)
_BNGetPlatformByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetPlatformByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNGetPlatformByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformCallingConventions
_BNGetPlatformCallingConventions = core.BNGetPlatformCallingConventions
_BNGetPlatformCallingConventions.restype = ctypes.POINTER(ctypes.POINTER(BNCallingConvention))
_BNGetPlatformCallingConventions.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformCallingConventions(
platform: ctypes.POINTER(BNPlatform),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNCallingConvention))]:
result = _BNGetPlatformCallingConventions(platform, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformCdeclCallingConvention
_BNGetPlatformCdeclCallingConvention = core.BNGetPlatformCdeclCallingConvention
_BNGetPlatformCdeclCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformCdeclCallingConvention.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetPlatformCdeclCallingConvention(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetPlatformCdeclCallingConvention(platform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformDefaultCallingConvention
_BNGetPlatformDefaultCallingConvention = core.BNGetPlatformDefaultCallingConvention
_BNGetPlatformDefaultCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformDefaultCallingConvention.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetPlatformDefaultCallingConvention(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetPlatformDefaultCallingConvention(platform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformFastcallCallingConvention
_BNGetPlatformFastcallCallingConvention = core.BNGetPlatformFastcallCallingConvention
_BNGetPlatformFastcallCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformFastcallCallingConvention.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetPlatformFastcallCallingConvention(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetPlatformFastcallCallingConvention(platform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformForViewType
_BNGetPlatformForViewType = core.BNGetPlatformForViewType
_BNGetPlatformForViewType.restype = ctypes.POINTER(BNPlatform)
_BNGetPlatformForViewType.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.c_uint,
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetPlatformForViewType(
type: ctypes.POINTER(BNBinaryViewType),
id: int,
arch: ctypes.POINTER(BNArchitecture)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNGetPlatformForViewType(type, id, arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformFunctionByName
_BNGetPlatformFunctionByName = core.BNGetPlatformFunctionByName
_BNGetPlatformFunctionByName.restype = ctypes.POINTER(BNType)
_BNGetPlatformFunctionByName.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNQualifiedName),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNGetPlatformFunctionByName(
platform: ctypes.POINTER(BNPlatform),
name: ctypes.POINTER(BNQualifiedName),
exactMatch: bool
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetPlatformFunctionByName(platform, name, exactMatch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformFunctions
_BNGetPlatformFunctions = core.BNGetPlatformFunctions
_BNGetPlatformFunctions.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetPlatformFunctions.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformFunctions(
platform: ctypes.POINTER(BNPlatform),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
result = _BNGetPlatformFunctions(platform, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformList
_BNGetPlatformList = core.BNGetPlatformList
_BNGetPlatformList.restype = ctypes.POINTER(ctypes.POINTER(BNPlatform))
_BNGetPlatformList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNPlatform))]:
result = _BNGetPlatformList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformListByArchitecture
_BNGetPlatformListByArchitecture = core.BNGetPlatformListByArchitecture
_BNGetPlatformListByArchitecture.restype = ctypes.POINTER(ctypes.POINTER(BNPlatform))
_BNGetPlatformListByArchitecture.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformListByArchitecture(
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNPlatform))]:
result = _BNGetPlatformListByArchitecture(arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformListByOS
_BNGetPlatformListByOS = core.BNGetPlatformListByOS
_BNGetPlatformListByOS.restype = ctypes.POINTER(ctypes.POINTER(BNPlatform))
_BNGetPlatformListByOS.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformListByOS(
os: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNPlatform))]:
result = _BNGetPlatformListByOS(cstr(os), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformListByOSAndArchitecture
_BNGetPlatformListByOSAndArchitecture = core.BNGetPlatformListByOSAndArchitecture
_BNGetPlatformListByOSAndArchitecture.restype = ctypes.POINTER(ctypes.POINTER(BNPlatform))
_BNGetPlatformListByOSAndArchitecture.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformListByOSAndArchitecture(
os: Optional[str],
arch: ctypes.POINTER(BNArchitecture),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNPlatform))]:
result = _BNGetPlatformListByOSAndArchitecture(cstr(os), arch, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformName
_BNGetPlatformName = core.BNGetPlatformName
_BNGetPlatformName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPlatformName.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetPlatformName(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[Optional[str]]:
result = _BNGetPlatformName(platform)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetPlatformOSList
_BNGetPlatformOSList = core.BNGetPlatformOSList
_BNGetPlatformOSList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetPlatformOSList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformOSList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetPlatformOSList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformStdcallCallingConvention
_BNGetPlatformStdcallCallingConvention = core.BNGetPlatformStdcallCallingConvention
_BNGetPlatformStdcallCallingConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformStdcallCallingConvention.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetPlatformStdcallCallingConvention(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetPlatformStdcallCallingConvention(platform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformSystemCallConvention
_BNGetPlatformSystemCallConvention = core.BNGetPlatformSystemCallConvention
_BNGetPlatformSystemCallConvention.restype = ctypes.POINTER(BNCallingConvention)
_BNGetPlatformSystemCallConvention.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetPlatformSystemCallConvention(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNGetPlatformSystemCallConvention(platform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformSystemCallName
_BNGetPlatformSystemCallName = core.BNGetPlatformSystemCallName
_BNGetPlatformSystemCallName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetPlatformSystemCallName.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetPlatformSystemCallName(
platform: ctypes.POINTER(BNPlatform),
number: int
) -> Optional[Optional[str]]:
result = _BNGetPlatformSystemCallName(platform, number)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetPlatformSystemCallType
_BNGetPlatformSystemCallType = core.BNGetPlatformSystemCallType
_BNGetPlatformSystemCallType.restype = ctypes.POINTER(BNType)
_BNGetPlatformSystemCallType.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetPlatformSystemCallType(
platform: ctypes.POINTER(BNPlatform),
number: int
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetPlatformSystemCallType(platform, number)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformSystemCalls
_BNGetPlatformSystemCalls = core.BNGetPlatformSystemCalls
_BNGetPlatformSystemCalls.restype = ctypes.POINTER(BNSystemCallInfo)
_BNGetPlatformSystemCalls.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformSystemCalls(
platform: ctypes.POINTER(BNPlatform),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNSystemCallInfo)]:
result = _BNGetPlatformSystemCalls(platform, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformTypeByName
_BNGetPlatformTypeByName = core.BNGetPlatformTypeByName
_BNGetPlatformTypeByName.restype = ctypes.POINTER(BNType)
_BNGetPlatformTypeByName.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGetPlatformTypeByName(
platform: ctypes.POINTER(BNPlatform),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetPlatformTypeByName(platform, name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformTypeContainer
_BNGetPlatformTypeContainer = core.BNGetPlatformTypeContainer
_BNGetPlatformTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetPlatformTypeContainer.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetPlatformTypeContainer(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[ctypes.POINTER(BNTypeContainer)]:
result = _BNGetPlatformTypeContainer(platform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformTypeLibraries
_BNGetPlatformTypeLibraries = core.BNGetPlatformTypeLibraries
_BNGetPlatformTypeLibraries.restype = ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))
_BNGetPlatformTypeLibraries.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformTypeLibraries(
platform: ctypes.POINTER(BNPlatform),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))]:
result = _BNGetPlatformTypeLibraries(platform, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformTypeLibrariesByName
_BNGetPlatformTypeLibrariesByName = core.BNGetPlatformTypeLibrariesByName
_BNGetPlatformTypeLibrariesByName.restype = ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))
_BNGetPlatformTypeLibrariesByName.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformTypeLibrariesByName(
platform: ctypes.POINTER(BNPlatform),
depName: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeLibrary))]:
result = _BNGetPlatformTypeLibrariesByName(platform, cstr(depName), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformTypes
_BNGetPlatformTypes = core.BNGetPlatformTypes
_BNGetPlatformTypes.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetPlatformTypes.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformTypes(
platform: ctypes.POINTER(BNPlatform),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
result = _BNGetPlatformTypes(platform, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformVariableByName
_BNGetPlatformVariableByName = core.BNGetPlatformVariableByName
_BNGetPlatformVariableByName.restype = ctypes.POINTER(BNType)
_BNGetPlatformVariableByName.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGetPlatformVariableByName(
platform: ctypes.POINTER(BNPlatform),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetPlatformVariableByName(platform, name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPlatformVariables
_BNGetPlatformVariables = core.BNGetPlatformVariables
_BNGetPlatformVariables.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetPlatformVariables.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetPlatformVariables(
platform: ctypes.POINTER(BNPlatform),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
result = _BNGetPlatformVariables(platform, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetPreviousBasicBlockEndBeforeAddress
_BNGetPreviousBasicBlockEndBeforeAddress = core.BNGetPreviousBasicBlockEndBeforeAddress
_BNGetPreviousBasicBlockEndBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousBasicBlockEndBeforeAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetPreviousBasicBlockEndBeforeAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> int:
return _BNGetPreviousBasicBlockEndBeforeAddress(view, addr)
# -------------------------------------------------------
# _BNGetPreviousBasicBlockStartBeforeAddress
_BNGetPreviousBasicBlockStartBeforeAddress = core.BNGetPreviousBasicBlockStartBeforeAddress
_BNGetPreviousBasicBlockStartBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousBasicBlockStartBeforeAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetPreviousBasicBlockStartBeforeAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> int:
return _BNGetPreviousBasicBlockStartBeforeAddress(view, addr)
# -------------------------------------------------------
# _BNGetPreviousDataBeforeAddress
_BNGetPreviousDataBeforeAddress = core.BNGetPreviousDataBeforeAddress
_BNGetPreviousDataBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousDataBeforeAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetPreviousDataBeforeAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> int:
return _BNGetPreviousDataBeforeAddress(view, addr)
# -------------------------------------------------------
# _BNGetPreviousDataVariableStartBeforeAddress
_BNGetPreviousDataVariableStartBeforeAddress = core.BNGetPreviousDataVariableStartBeforeAddress
_BNGetPreviousDataVariableStartBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousDataVariableStartBeforeAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetPreviousDataVariableStartBeforeAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> int:
return _BNGetPreviousDataVariableStartBeforeAddress(view, addr)
# -------------------------------------------------------
# _BNGetPreviousFunctionStartBeforeAddress
_BNGetPreviousFunctionStartBeforeAddress = core.BNGetPreviousFunctionStartBeforeAddress
_BNGetPreviousFunctionStartBeforeAddress.restype = ctypes.c_ulonglong
_BNGetPreviousFunctionStartBeforeAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetPreviousFunctionStartBeforeAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> int:
return _BNGetPreviousFunctionStartBeforeAddress(view, addr)
# -------------------------------------------------------
# _BNGetPreviousLinearViewObjectChild
_BNGetPreviousLinearViewObjectChild = core.BNGetPreviousLinearViewObjectChild
_BNGetPreviousLinearViewObjectChild.restype = ctypes.POINTER(BNLinearViewObject)
_BNGetPreviousLinearViewObjectChild.argtypes = [
ctypes.POINTER(BNLinearViewObject),
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNGetPreviousLinearViewObjectChild(
parent: ctypes.POINTER(BNLinearViewObject),
child: ctypes.POINTER(BNLinearViewObject)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNGetPreviousLinearViewObjectChild(parent, child)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetProduct
_BNGetProduct = core.BNGetProduct
_BNGetProduct.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetProduct.argtypes = [
]
# noinspection PyPep8Naming
def BNGetProduct(
) -> Optional[Optional[str]]:
result = _BNGetProduct()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetProductType
_BNGetProductType = core.BNGetProductType
_BNGetProductType.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetProductType.argtypes = [
]
# noinspection PyPep8Naming
def BNGetProductType(
) -> Optional[Optional[str]]:
result = _BNGetProductType()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetProjectFile
_BNGetProjectFile = core.BNGetProjectFile
_BNGetProjectFile.restype = ctypes.POINTER(BNProjectFile)
_BNGetProjectFile.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNGetProjectFile(
file: ctypes.POINTER(BNFileMetadata)
) -> Optional[ctypes.POINTER(BNProjectFile)]:
result = _BNGetProjectFile(file)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetProvenanceString
_BNGetProvenanceString = core.BNGetProvenanceString
_BNGetProvenanceString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetProvenanceString.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetProvenanceString(
func: ctypes.POINTER(BNFunction)
) -> Optional[Optional[str]]:
result = _BNGetProvenanceString(func)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetReaderPosition
_BNGetReaderPosition = core.BNGetReaderPosition
_BNGetReaderPosition.restype = ctypes.c_ulonglong
_BNGetReaderPosition.argtypes = [
ctypes.POINTER(BNBinaryReader),
]
# noinspection PyPep8Naming
def BNGetReaderPosition(
stream: ctypes.POINTER(BNBinaryReader)
) -> int:
return _BNGetReaderPosition(stream)
# -------------------------------------------------------
# _BNGetRecentAnalysisFunctionForAddress
_BNGetRecentAnalysisFunctionForAddress = core.BNGetRecentAnalysisFunctionForAddress
_BNGetRecentAnalysisFunctionForAddress.restype = ctypes.POINTER(BNFunction)
_BNGetRecentAnalysisFunctionForAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetRecentAnalysisFunctionForAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNGetRecentAnalysisFunctionForAddress(view, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRecentBasicBlockForAddress
_BNGetRecentBasicBlockForAddress = core.BNGetRecentBasicBlockForAddress
_BNGetRecentBasicBlockForAddress.restype = ctypes.POINTER(BNBasicBlock)
_BNGetRecentBasicBlockForAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetRecentBasicBlockForAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNGetRecentBasicBlockForAddress(view, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRedoEntries
_BNGetRedoEntries = core.BNGetRedoEntries
_BNGetRedoEntries.restype = ctypes.POINTER(BNUndoEntry)
_BNGetRedoEntries.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetRedoEntries(
file: ctypes.POINTER(BNFileMetadata),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNUndoEntry)]:
result = _BNGetRedoEntries(file, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRegisterStackAdjustments
_BNGetRegisterStackAdjustments = core.BNGetRegisterStackAdjustments
_BNGetRegisterStackAdjustments.restype = ctypes.c_ulonglong
_BNGetRegisterStackAdjustments.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(ctypes.c_uint),
ctypes.c_ulonglong,
ctypes.POINTER(BNType),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.POINTER(ctypes.c_uint)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_uint)),
]
# noinspection PyPep8Naming
def BNGetRegisterStackAdjustments(
cc: ctypes.POINTER(BNCallingConvention),
returnRegs: ctypes.POINTER(ctypes.c_uint),
returnRegCount: int,
returnType: ctypes.POINTER(BNType),
params: ctypes.POINTER(BNVariable),
paramCount: int,
types: ctypes.POINTER(ctypes.POINTER(BNType)),
typeCount: int,
resultRegisters: ctypes.POINTER(ctypes.POINTER(ctypes.c_uint)),
resultAdjustments: ctypes.POINTER(ctypes.POINTER(ctypes.c_uint))
) -> int:
return _BNGetRegisterStackAdjustments(cc, returnRegs, returnRegCount, returnType, params, paramCount, types, typeCount, resultRegisters, resultAdjustments)
# -------------------------------------------------------
# _BNGetRegisterValueAfterInstruction
_BNGetRegisterValueAfterInstruction = core.BNGetRegisterValueAfterInstruction
_BNGetRegisterValueAfterInstruction.restype = BNRegisterValue
_BNGetRegisterValueAfterInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetRegisterValueAfterInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
reg: int
) -> BNRegisterValue:
return _BNGetRegisterValueAfterInstruction(func, arch, addr, reg)
# -------------------------------------------------------
# _BNGetRegisterValueAtInstruction
_BNGetRegisterValueAtInstruction = core.BNGetRegisterValueAtInstruction
_BNGetRegisterValueAtInstruction.restype = BNRegisterValue
_BNGetRegisterValueAtInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNGetRegisterValueAtInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
reg: int
) -> BNRegisterValue:
return _BNGetRegisterValueAtInstruction(func, arch, addr, reg)
# -------------------------------------------------------
# _BNGetRegisteredTypeName
_BNGetRegisteredTypeName = core.BNGetRegisteredTypeName
_BNGetRegisteredTypeName.restype = ctypes.POINTER(BNNamedTypeReference)
_BNGetRegisteredTypeName.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetRegisteredTypeName(
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
result = _BNGetRegisteredTypeName(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRegistersReadByInstruction
_BNGetRegistersReadByInstruction = core.BNGetRegistersReadByInstruction
_BNGetRegistersReadByInstruction.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetRegistersReadByInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetRegistersReadByInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetRegistersReadByInstruction(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRegistersWrittenByInstruction
_BNGetRegistersWrittenByInstruction = core.BNGetRegistersWrittenByInstruction
_BNGetRegistersWrittenByInstruction.restype = ctypes.POINTER(ctypes.c_uint)
_BNGetRegistersWrittenByInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetRegistersWrittenByInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_uint)]:
result = _BNGetRegistersWrittenByInstruction(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRelatedPlatform
_BNGetRelatedPlatform = core.BNGetRelatedPlatform
_BNGetRelatedPlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetRelatedPlatform.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNGetRelatedPlatform(
platform: ctypes.POINTER(BNPlatform),
arch: ctypes.POINTER(BNArchitecture)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNGetRelatedPlatform(platform, arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRelocationRanges
_BNGetRelocationRanges = core.BNGetRelocationRanges
_BNGetRelocationRanges.restype = ctypes.POINTER(BNRange)
_BNGetRelocationRanges.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetRelocationRanges(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNRange)]:
result = _BNGetRelocationRanges(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRelocationRangesAtAddress
_BNGetRelocationRangesAtAddress = core.BNGetRelocationRangesAtAddress
_BNGetRelocationRangesAtAddress.restype = ctypes.POINTER(BNRange)
_BNGetRelocationRangesAtAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetRelocationRangesAtAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNRange)]:
result = _BNGetRelocationRangesAtAddress(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRelocationsAt
_BNGetRelocationsAt = core.BNGetRelocationsAt
_BNGetRelocationsAt.restype = ctypes.POINTER(ctypes.POINTER(BNRelocation))
_BNGetRelocationsAt.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetRelocationsAt(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNRelocation))]:
result = _BNGetRelocationsAt(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetReportCollectionCount
_BNGetReportCollectionCount = core.BNGetReportCollectionCount
_BNGetReportCollectionCount.restype = ctypes.c_ulonglong
_BNGetReportCollectionCount.argtypes = [
ctypes.POINTER(BNReportCollection),
]
# noinspection PyPep8Naming
def BNGetReportCollectionCount(
reports: ctypes.POINTER(BNReportCollection)
) -> int:
return _BNGetReportCollectionCount(reports)
# -------------------------------------------------------
# _BNGetReportContents
_BNGetReportContents = core.BNGetReportContents
_BNGetReportContents.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetReportContents.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetReportContents(
reports: ctypes.POINTER(BNReportCollection),
i: int
) -> Optional[Optional[str]]:
result = _BNGetReportContents(reports, i)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetReportFlowGraph
_BNGetReportFlowGraph = core.BNGetReportFlowGraph
_BNGetReportFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNGetReportFlowGraph.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetReportFlowGraph(
reports: ctypes.POINTER(BNReportCollection),
i: int
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNGetReportFlowGraph(reports, i)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetReportPlainText
_BNGetReportPlainText = core.BNGetReportPlainText
_BNGetReportPlainText.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetReportPlainText.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetReportPlainText(
reports: ctypes.POINTER(BNReportCollection),
i: int
) -> Optional[Optional[str]]:
result = _BNGetReportPlainText(reports, i)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetReportTitle
_BNGetReportTitle = core.BNGetReportTitle
_BNGetReportTitle.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetReportTitle.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetReportTitle(
reports: ctypes.POINTER(BNReportCollection),
i: int
) -> Optional[Optional[str]]:
result = _BNGetReportTitle(reports, i)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetReportType
_BNGetReportType = core.BNGetReportType
_BNGetReportType.restype = ReportTypeEnum
_BNGetReportType.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetReportType(
reports: ctypes.POINTER(BNReportCollection),
i: int
) -> ReportType:
return _BNGetReportType(reports, i)
# -------------------------------------------------------
# _BNGetReportView
_BNGetReportView = core.BNGetReportView
_BNGetReportView.restype = ctypes.POINTER(BNBinaryView)
_BNGetReportView.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetReportView(
reports: ctypes.POINTER(BNReportCollection),
i: int
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNGetReportView(reports, i)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRepositoriesDirectory
_BNGetRepositoriesDirectory = core.BNGetRepositoriesDirectory
_BNGetRepositoriesDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetRepositoriesDirectory.argtypes = [
]
# noinspection PyPep8Naming
def BNGetRepositoriesDirectory(
) -> Optional[Optional[str]]:
result = _BNGetRepositoriesDirectory()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetRepositoryManager
_BNGetRepositoryManager = core.BNGetRepositoryManager
_BNGetRepositoryManager.restype = ctypes.POINTER(BNRepositoryManager)
_BNGetRepositoryManager.argtypes = [
]
# noinspection PyPep8Naming
def BNGetRepositoryManager(
) -> Optional[ctypes.POINTER(BNRepositoryManager)]:
result = _BNGetRepositoryManager()
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRootComponent
_BNGetRootComponent = core.BNGetRootComponent
_BNGetRootComponent.restype = ctypes.POINTER(BNComponent)
_BNGetRootComponent.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetRootComponent(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNComponent)]:
result = _BNGetRootComponent(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetRunningBackgroundTasks
_BNGetRunningBackgroundTasks = core.BNGetRunningBackgroundTasks
_BNGetRunningBackgroundTasks.restype = ctypes.POINTER(ctypes.POINTER(BNBackgroundTask))
_BNGetRunningBackgroundTasks.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetRunningBackgroundTasks(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNBackgroundTask))]:
result = _BNGetRunningBackgroundTasks(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSaveFileNameInput
_BNGetSaveFileNameInput = core.BNGetSaveFileNameInput
_BNGetSaveFileNameInput.restype = ctypes.c_bool
_BNGetSaveFileNameInput.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetSaveFileNameInput(
result: ctypes.POINTER(ctypes.c_char_p),
prompt: Optional[str],
ext: Optional[str],
defaultName: Optional[str]
) -> bool:
return _BNGetSaveFileNameInput(result, cstr(prompt), cstr(ext), cstr(defaultName))
# -------------------------------------------------------
# _BNGetSaveSettingsName
_BNGetSaveSettingsName = core.BNGetSaveSettingsName
_BNGetSaveSettingsName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSaveSettingsName.argtypes = [
ctypes.POINTER(BNSaveSettings),
]
# noinspection PyPep8Naming
def BNGetSaveSettingsName(
settings: ctypes.POINTER(BNSaveSettings)
) -> Optional[Optional[str]]:
result = _BNGetSaveSettingsName(settings)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetScriptingInstanceDelimiters
_BNGetScriptingInstanceDelimiters = core.BNGetScriptingInstanceDelimiters
_BNGetScriptingInstanceDelimiters.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetScriptingInstanceDelimiters.argtypes = [
ctypes.POINTER(BNScriptingInstance),
]
# noinspection PyPep8Naming
def BNGetScriptingInstanceDelimiters(
instance: ctypes.POINTER(BNScriptingInstance)
) -> Optional[Optional[str]]:
result = _BNGetScriptingInstanceDelimiters(instance)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetScriptingInstanceInputReadyState
_BNGetScriptingInstanceInputReadyState = core.BNGetScriptingInstanceInputReadyState
_BNGetScriptingInstanceInputReadyState.restype = ScriptingProviderInputReadyStateEnum
_BNGetScriptingInstanceInputReadyState.argtypes = [
ctypes.POINTER(BNScriptingInstance),
]
# noinspection PyPep8Naming
def BNGetScriptingInstanceInputReadyState(
instance: ctypes.POINTER(BNScriptingInstance)
) -> ScriptingProviderInputReadyState:
return _BNGetScriptingInstanceInputReadyState(instance)
# -------------------------------------------------------
# _BNGetScriptingProviderAPIName
_BNGetScriptingProviderAPIName = core.BNGetScriptingProviderAPIName
_BNGetScriptingProviderAPIName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetScriptingProviderAPIName.argtypes = [
ctypes.POINTER(BNScriptingProvider),
]
# noinspection PyPep8Naming
def BNGetScriptingProviderAPIName(
provider: ctypes.POINTER(BNScriptingProvider)
) -> Optional[Optional[str]]:
result = _BNGetScriptingProviderAPIName(provider)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetScriptingProviderByAPIName
_BNGetScriptingProviderByAPIName = core.BNGetScriptingProviderByAPIName
_BNGetScriptingProviderByAPIName.restype = ctypes.POINTER(BNScriptingProvider)
_BNGetScriptingProviderByAPIName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetScriptingProviderByAPIName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNScriptingProvider)]:
result = _BNGetScriptingProviderByAPIName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetScriptingProviderByName
_BNGetScriptingProviderByName = core.BNGetScriptingProviderByName
_BNGetScriptingProviderByName.restype = ctypes.POINTER(BNScriptingProvider)
_BNGetScriptingProviderByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetScriptingProviderByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNScriptingProvider)]:
result = _BNGetScriptingProviderByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetScriptingProviderList
_BNGetScriptingProviderList = core.BNGetScriptingProviderList
_BNGetScriptingProviderList.restype = ctypes.POINTER(ctypes.POINTER(BNScriptingProvider))
_BNGetScriptingProviderList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetScriptingProviderList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNScriptingProvider))]:
result = _BNGetScriptingProviderList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetScriptingProviderName
_BNGetScriptingProviderName = core.BNGetScriptingProviderName
_BNGetScriptingProviderName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetScriptingProviderName.argtypes = [
ctypes.POINTER(BNScriptingProvider),
]
# noinspection PyPep8Naming
def BNGetScriptingProviderName(
provider: ctypes.POINTER(BNScriptingProvider)
) -> Optional[Optional[str]]:
result = _BNGetScriptingProviderName(provider)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetSecretsProviderByName
_BNGetSecretsProviderByName = core.BNGetSecretsProviderByName
_BNGetSecretsProviderByName.restype = ctypes.POINTER(BNSecretsProvider)
_BNGetSecretsProviderByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetSecretsProviderByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNSecretsProvider)]:
result = _BNGetSecretsProviderByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSecretsProviderData
_BNGetSecretsProviderData = core.BNGetSecretsProviderData
_BNGetSecretsProviderData.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSecretsProviderData.argtypes = [
ctypes.POINTER(BNSecretsProvider),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetSecretsProviderData(
provider: ctypes.POINTER(BNSecretsProvider),
key: Optional[str]
) -> Optional[Optional[str]]:
result = _BNGetSecretsProviderData(provider, cstr(key))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetSecretsProviderList
_BNGetSecretsProviderList = core.BNGetSecretsProviderList
_BNGetSecretsProviderList.restype = ctypes.POINTER(ctypes.POINTER(BNSecretsProvider))
_BNGetSecretsProviderList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSecretsProviderList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSecretsProvider))]:
result = _BNGetSecretsProviderList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSecretsProviderName
_BNGetSecretsProviderName = core.BNGetSecretsProviderName
_BNGetSecretsProviderName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSecretsProviderName.argtypes = [
ctypes.POINTER(BNSecretsProvider),
]
# noinspection PyPep8Naming
def BNGetSecretsProviderName(
provider: ctypes.POINTER(BNSecretsProvider)
) -> Optional[Optional[str]]:
result = _BNGetSecretsProviderName(provider)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetSectionByName
_BNGetSectionByName = core.BNGetSectionByName
_BNGetSectionByName.restype = ctypes.POINTER(BNSection)
_BNGetSectionByName.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetSectionByName(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNSection)]:
result = _BNGetSectionByName(view, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSections
_BNGetSections = core.BNGetSections
_BNGetSections.restype = ctypes.POINTER(ctypes.POINTER(BNSection))
_BNGetSections.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSections(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSection))]:
result = _BNGetSections(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSectionsAt
_BNGetSectionsAt = core.BNGetSectionsAt
_BNGetSectionsAt.restype = ctypes.POINTER(ctypes.POINTER(BNSection))
_BNGetSectionsAt.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSectionsAt(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSection))]:
result = _BNGetSectionsAt(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSegmentAt
_BNGetSegmentAt = core.BNGetSegmentAt
_BNGetSegmentAt.restype = ctypes.POINTER(BNSegment)
_BNGetSegmentAt.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetSegmentAt(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> Optional[ctypes.POINTER(BNSegment)]:
result = _BNGetSegmentAt(view, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSegments
_BNGetSegments = core.BNGetSegments
_BNGetSegments.restype = ctypes.POINTER(ctypes.POINTER(BNSegment))
_BNGetSegments.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSegments(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSegment))]:
result = _BNGetSegments(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSerialNumber
_BNGetSerialNumber = core.BNGetSerialNumber
_BNGetSerialNumber.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSerialNumber.argtypes = [
]
# noinspection PyPep8Naming
def BNGetSerialNumber(
) -> Optional[Optional[str]]:
result = _BNGetSerialNumber()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetSettingsFileName
_BNGetSettingsFileName = core.BNGetSettingsFileName
_BNGetSettingsFileName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSettingsFileName.argtypes = [
]
# noinspection PyPep8Naming
def BNGetSettingsFileName(
) -> Optional[Optional[str]]:
result = _BNGetSettingsFileName()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetSizesReferenced
_BNGetSizesReferenced = core.BNGetSizesReferenced
_BNGetSizesReferenced.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetSizesReferenced.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSizesReferenced(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
offset: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetSizesReferenced(view, type, offset, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSnapshotChildren
_BNGetSnapshotChildren = core.BNGetSnapshotChildren
_BNGetSnapshotChildren.restype = ctypes.POINTER(ctypes.POINTER(BNSnapshot))
_BNGetSnapshotChildren.argtypes = [
ctypes.POINTER(BNSnapshot),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSnapshotChildren(
snapshot: ctypes.POINTER(BNSnapshot),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSnapshot))]:
result = _BNGetSnapshotChildren(snapshot, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSnapshotData
_BNGetSnapshotData = core.BNGetSnapshotData
_BNGetSnapshotData.restype = None
_BNGetSnapshotData.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(BNKeyValueStore),
ctypes.POINTER(BNKeyValueStore),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSnapshotData(
file: ctypes.POINTER(BNFileMetadata),
data: ctypes.POINTER(BNKeyValueStore),
cache: ctypes.POINTER(BNKeyValueStore),
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> None:
return _BNGetSnapshotData(file, data, cache, ctxt, progress)
# -------------------------------------------------------
# _BNGetSnapshotDatabase
_BNGetSnapshotDatabase = core.BNGetSnapshotDatabase
_BNGetSnapshotDatabase.restype = ctypes.POINTER(BNDatabase)
_BNGetSnapshotDatabase.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNGetSnapshotDatabase(
snapshot: ctypes.POINTER(BNSnapshot)
) -> Optional[ctypes.POINTER(BNDatabase)]:
result = _BNGetSnapshotDatabase(snapshot)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSnapshotFileContents
_BNGetSnapshotFileContents = core.BNGetSnapshotFileContents
_BNGetSnapshotFileContents.restype = ctypes.POINTER(BNDataBuffer)
_BNGetSnapshotFileContents.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNGetSnapshotFileContents(
snapshot: ctypes.POINTER(BNSnapshot)
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNGetSnapshotFileContents(snapshot)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSnapshotFileContentsHash
_BNGetSnapshotFileContentsHash = core.BNGetSnapshotFileContentsHash
_BNGetSnapshotFileContentsHash.restype = ctypes.POINTER(BNDataBuffer)
_BNGetSnapshotFileContentsHash.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNGetSnapshotFileContentsHash(
snapshot: ctypes.POINTER(BNSnapshot)
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNGetSnapshotFileContentsHash(snapshot)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSnapshotFirstParent
_BNGetSnapshotFirstParent = core.BNGetSnapshotFirstParent
_BNGetSnapshotFirstParent.restype = ctypes.POINTER(BNSnapshot)
_BNGetSnapshotFirstParent.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNGetSnapshotFirstParent(
snapshot: ctypes.POINTER(BNSnapshot)
) -> Optional[ctypes.POINTER(BNSnapshot)]:
result = _BNGetSnapshotFirstParent(snapshot)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSnapshotId
_BNGetSnapshotId = core.BNGetSnapshotId
_BNGetSnapshotId.restype = ctypes.c_longlong
_BNGetSnapshotId.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNGetSnapshotId(
snapshot: ctypes.POINTER(BNSnapshot)
) -> int:
return _BNGetSnapshotId(snapshot)
# -------------------------------------------------------
# _BNGetSnapshotName
_BNGetSnapshotName = core.BNGetSnapshotName
_BNGetSnapshotName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSnapshotName.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNGetSnapshotName(
snapshot: ctypes.POINTER(BNSnapshot)
) -> Optional[Optional[str]]:
result = _BNGetSnapshotName(snapshot)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetSnapshotParents
_BNGetSnapshotParents = core.BNGetSnapshotParents
_BNGetSnapshotParents.restype = ctypes.POINTER(ctypes.POINTER(BNSnapshot))
_BNGetSnapshotParents.argtypes = [
ctypes.POINTER(BNSnapshot),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSnapshotParents(
snapshot: ctypes.POINTER(BNSnapshot),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSnapshot))]:
result = _BNGetSnapshotParents(snapshot, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSnapshotUndoData
_BNGetSnapshotUndoData = core.BNGetSnapshotUndoData
_BNGetSnapshotUndoData.restype = ctypes.POINTER(BNDataBuffer)
_BNGetSnapshotUndoData.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNGetSnapshotUndoData(
snapshot: ctypes.POINTER(BNSnapshot)
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNGetSnapshotUndoData(snapshot)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSnapshotUndoEntries
_BNGetSnapshotUndoEntries = core.BNGetSnapshotUndoEntries
_BNGetSnapshotUndoEntries.restype = ctypes.POINTER(BNUndoEntry)
_BNGetSnapshotUndoEntries.argtypes = [
ctypes.POINTER(BNSnapshot),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSnapshotUndoEntries(
snapshot: ctypes.POINTER(BNSnapshot),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNUndoEntry)]:
result = _BNGetSnapshotUndoEntries(snapshot, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSnapshotUndoEntriesWithProgress
_BNGetSnapshotUndoEntriesWithProgress = core.BNGetSnapshotUndoEntriesWithProgress
_BNGetSnapshotUndoEntriesWithProgress.restype = ctypes.POINTER(BNUndoEntry)
_BNGetSnapshotUndoEntriesWithProgress.argtypes = [
ctypes.POINTER(BNSnapshot),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSnapshotUndoEntriesWithProgress(
snapshot: ctypes.POINTER(BNSnapshot),
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNUndoEntry)]:
result = _BNGetSnapshotUndoEntriesWithProgress(snapshot, ctxt, progress, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSplitVariables
_BNGetSplitVariables = core.BNGetSplitVariables
_BNGetSplitVariables.restype = ctypes.POINTER(BNVariable)
_BNGetSplitVariables.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSplitVariables(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariable)]:
result = _BNGetSplitVariables(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStackAdjustmentForVariables
_BNGetStackAdjustmentForVariables = core.BNGetStackAdjustmentForVariables
_BNGetStackAdjustmentForVariables.restype = ctypes.c_longlong
_BNGetStackAdjustmentForVariables.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(BNVariable),
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetStackAdjustmentForVariables(
cc: ctypes.POINTER(BNCallingConvention),
paramVars: ctypes.POINTER(BNVariable),
paramTypes: ctypes.POINTER(ctypes.POINTER(BNType)),
paramCount: int
) -> int:
return _BNGetStackAdjustmentForVariables(cc, paramVars, paramTypes, paramCount)
# -------------------------------------------------------
# _BNGetStackContentsAfterInstruction
_BNGetStackContentsAfterInstruction = core.BNGetStackContentsAfterInstruction
_BNGetStackContentsAfterInstruction.restype = BNRegisterValue
_BNGetStackContentsAfterInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_longlong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetStackContentsAfterInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
offset: int,
size: int
) -> BNRegisterValue:
return _BNGetStackContentsAfterInstruction(func, arch, addr, offset, size)
# -------------------------------------------------------
# _BNGetStackContentsAtInstruction
_BNGetStackContentsAtInstruction = core.BNGetStackContentsAtInstruction
_BNGetStackContentsAtInstruction.restype = BNRegisterValue
_BNGetStackContentsAtInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_longlong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetStackContentsAtInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
offset: int,
size: int
) -> BNRegisterValue:
return _BNGetStackContentsAtInstruction(func, arch, addr, offset, size)
# -------------------------------------------------------
# _BNGetStackLayout
_BNGetStackLayout = core.BNGetStackLayout
_BNGetStackLayout.restype = ctypes.POINTER(BNVariableNameAndType)
_BNGetStackLayout.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStackLayout(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariableNameAndType)]:
result = _BNGetStackLayout(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStackVariableAtFrameOffset
_BNGetStackVariableAtFrameOffset = core.BNGetStackVariableAtFrameOffset
_BNGetStackVariableAtFrameOffset.restype = ctypes.c_bool
_BNGetStackVariableAtFrameOffset.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_longlong,
ctypes.POINTER(BNVariableNameAndType),
]
# noinspection PyPep8Naming
def BNGetStackVariableAtFrameOffset(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
offset: int,
var: ctypes.POINTER(BNVariableNameAndType)
) -> bool:
return _BNGetStackVariableAtFrameOffset(func, arch, addr, offset, var)
# -------------------------------------------------------
# _BNGetStackVariablesReferencedByInstruction
_BNGetStackVariablesReferencedByInstruction = core.BNGetStackVariablesReferencedByInstruction
_BNGetStackVariablesReferencedByInstruction.restype = ctypes.POINTER(BNStackVariableReference)
_BNGetStackVariablesReferencedByInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStackVariablesReferencedByInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNStackVariableReference)]:
result = _BNGetStackVariablesReferencedByInstruction(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStackVariablesReferencedByInstructionIfAvailable
_BNGetStackVariablesReferencedByInstructionIfAvailable = core.BNGetStackVariablesReferencedByInstructionIfAvailable
_BNGetStackVariablesReferencedByInstructionIfAvailable.restype = ctypes.POINTER(BNStackVariableReference)
_BNGetStackVariablesReferencedByInstructionIfAvailable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStackVariablesReferencedByInstructionIfAvailable(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNStackVariableReference)]:
result = _BNGetStackVariablesReferencedByInstructionIfAvailable(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStartOffset
_BNGetStartOffset = core.BNGetStartOffset
_BNGetStartOffset.restype = ctypes.c_ulonglong
_BNGetStartOffset.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetStartOffset(
view: ctypes.POINTER(BNBinaryView)
) -> int:
return _BNGetStartOffset(view)
# -------------------------------------------------------
# _BNGetStringAtAddress
_BNGetStringAtAddress = core.BNGetStringAtAddress
_BNGetStringAtAddress.restype = ctypes.c_bool
_BNGetStringAtAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNStringReference),
]
# noinspection PyPep8Naming
def BNGetStringAtAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
strRef: ctypes.POINTER(BNStringReference)
) -> bool:
return _BNGetStringAtAddress(view, addr, strRef)
# -------------------------------------------------------
# _BNGetStrings
_BNGetStrings = core.BNGetStrings
_BNGetStrings.restype = ctypes.POINTER(BNStringReference)
_BNGetStrings.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStrings(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNStringReference)]:
result = _BNGetStrings(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStringsInRange
_BNGetStringsInRange = core.BNGetStringsInRange
_BNGetStringsInRange.restype = ctypes.POINTER(BNStringReference)
_BNGetStringsInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStringsInRange(
view: ctypes.POINTER(BNBinaryView),
start: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNStringReference)]:
result = _BNGetStringsInRange(view, start, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStructureAlignment
_BNGetStructureAlignment = core.BNGetStructureAlignment
_BNGetStructureAlignment.restype = ctypes.c_ulonglong
_BNGetStructureAlignment.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNGetStructureAlignment(
s: ctypes.POINTER(BNStructure)
) -> int:
return _BNGetStructureAlignment(s)
# -------------------------------------------------------
# _BNGetStructureBuilderAlignment
_BNGetStructureBuilderAlignment = core.BNGetStructureBuilderAlignment
_BNGetStructureBuilderAlignment.restype = ctypes.c_ulonglong
_BNGetStructureBuilderAlignment.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNGetStructureBuilderAlignment(
s: ctypes.POINTER(BNStructureBuilder)
) -> int:
return _BNGetStructureBuilderAlignment(s)
# -------------------------------------------------------
# _BNGetStructureBuilderMemberAtOffset
_BNGetStructureBuilderMemberAtOffset = core.BNGetStructureBuilderMemberAtOffset
_BNGetStructureBuilderMemberAtOffset.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureBuilderMemberAtOffset.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.c_longlong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStructureBuilderMemberAtOffset(
s: ctypes.POINTER(BNStructureBuilder),
offset: int,
idx: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNStructureMember)]:
result = _BNGetStructureBuilderMemberAtOffset(s, offset, idx)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStructureBuilderMemberByName
_BNGetStructureBuilderMemberByName = core.BNGetStructureBuilderMemberByName
_BNGetStructureBuilderMemberByName.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureBuilderMemberByName.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetStructureBuilderMemberByName(
s: ctypes.POINTER(BNStructureBuilder),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNStructureMember)]:
result = _BNGetStructureBuilderMemberByName(s, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStructureBuilderMembers
_BNGetStructureBuilderMembers = core.BNGetStructureBuilderMembers
_BNGetStructureBuilderMembers.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureBuilderMembers.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStructureBuilderMembers(
s: ctypes.POINTER(BNStructureBuilder),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNStructureMember)]:
result = _BNGetStructureBuilderMembers(s, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStructureBuilderPointerOffset
_BNGetStructureBuilderPointerOffset = core.BNGetStructureBuilderPointerOffset
_BNGetStructureBuilderPointerOffset.restype = ctypes.c_longlong
_BNGetStructureBuilderPointerOffset.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNGetStructureBuilderPointerOffset(
s: ctypes.POINTER(BNStructureBuilder)
) -> int:
return _BNGetStructureBuilderPointerOffset(s)
# -------------------------------------------------------
# _BNGetStructureBuilderType
_BNGetStructureBuilderType = core.BNGetStructureBuilderType
_BNGetStructureBuilderType.restype = StructureVariantEnum
_BNGetStructureBuilderType.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNGetStructureBuilderType(
s: ctypes.POINTER(BNStructureBuilder)
) -> StructureVariant:
return _BNGetStructureBuilderType(s)
# -------------------------------------------------------
# _BNGetStructureBuilderWidth
_BNGetStructureBuilderWidth = core.BNGetStructureBuilderWidth
_BNGetStructureBuilderWidth.restype = ctypes.c_ulonglong
_BNGetStructureBuilderWidth.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNGetStructureBuilderWidth(
s: ctypes.POINTER(BNStructureBuilder)
) -> int:
return _BNGetStructureBuilderWidth(s)
# -------------------------------------------------------
# _BNGetStructureMemberAtOffset
_BNGetStructureMemberAtOffset = core.BNGetStructureMemberAtOffset
_BNGetStructureMemberAtOffset.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureMemberAtOffset.argtypes = [
ctypes.POINTER(BNStructure),
ctypes.c_longlong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStructureMemberAtOffset(
s: ctypes.POINTER(BNStructure),
offset: int,
idx: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNStructureMember)]:
result = _BNGetStructureMemberAtOffset(s, offset, idx)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStructureMemberByName
_BNGetStructureMemberByName = core.BNGetStructureMemberByName
_BNGetStructureMemberByName.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureMemberByName.argtypes = [
ctypes.POINTER(BNStructure),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetStructureMemberByName(
s: ctypes.POINTER(BNStructure),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNStructureMember)]:
result = _BNGetStructureMemberByName(s, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStructureMembers
_BNGetStructureMembers = core.BNGetStructureMembers
_BNGetStructureMembers.restype = ctypes.POINTER(BNStructureMember)
_BNGetStructureMembers.argtypes = [
ctypes.POINTER(BNStructure),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStructureMembers(
s: ctypes.POINTER(BNStructure),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNStructureMember)]:
result = _BNGetStructureMembers(s, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStructureMembersIncludingInherited
_BNGetStructureMembersIncludingInherited = core.BNGetStructureMembersIncludingInherited
_BNGetStructureMembersIncludingInherited.restype = ctypes.POINTER(BNInheritedStructureMember)
_BNGetStructureMembersIncludingInherited.argtypes = [
ctypes.POINTER(BNStructure),
ctypes.POINTER(BNTypeContainer),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetStructureMembersIncludingInherited(
s: ctypes.POINTER(BNStructure),
types: ctypes.POINTER(BNTypeContainer),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInheritedStructureMember)]:
result = _BNGetStructureMembersIncludingInherited(s, types, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetStructurePointerOffset
_BNGetStructurePointerOffset = core.BNGetStructurePointerOffset
_BNGetStructurePointerOffset.restype = ctypes.c_longlong
_BNGetStructurePointerOffset.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNGetStructurePointerOffset(
s: ctypes.POINTER(BNStructure)
) -> int:
return _BNGetStructurePointerOffset(s)
# -------------------------------------------------------
# _BNGetStructureType
_BNGetStructureType = core.BNGetStructureType
_BNGetStructureType.restype = StructureVariantEnum
_BNGetStructureType.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNGetStructureType(
s: ctypes.POINTER(BNStructure)
) -> StructureVariant:
return _BNGetStructureType(s)
# -------------------------------------------------------
# _BNGetStructureWidth
_BNGetStructureWidth = core.BNGetStructureWidth
_BNGetStructureWidth.restype = ctypes.c_ulonglong
_BNGetStructureWidth.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNGetStructureWidth(
s: ctypes.POINTER(BNStructure)
) -> int:
return _BNGetStructureWidth(s)
# -------------------------------------------------------
# _BNGetSymbolAddress
_BNGetSymbolAddress = core.BNGetSymbolAddress
_BNGetSymbolAddress.restype = ctypes.c_ulonglong
_BNGetSymbolAddress.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNGetSymbolAddress(
sym: ctypes.POINTER(BNSymbol)
) -> int:
return _BNGetSymbolAddress(sym)
# -------------------------------------------------------
# _BNGetSymbolBinding
_BNGetSymbolBinding = core.BNGetSymbolBinding
_BNGetSymbolBinding.restype = SymbolBindingEnum
_BNGetSymbolBinding.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNGetSymbolBinding(
sym: ctypes.POINTER(BNSymbol)
) -> SymbolBinding:
return _BNGetSymbolBinding(sym)
# -------------------------------------------------------
# _BNGetSymbolByAddress
_BNGetSymbolByAddress = core.BNGetSymbolByAddress
_BNGetSymbolByAddress.restype = ctypes.POINTER(BNSymbol)
_BNGetSymbolByAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNGetSymbolByAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
nameSpace: ctypes.POINTER(BNNameSpace)
) -> Optional[ctypes.POINTER(BNSymbol)]:
result = _BNGetSymbolByAddress(view, addr, nameSpace)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSymbolByRawName
_BNGetSymbolByRawName = core.BNGetSymbolByRawName
_BNGetSymbolByRawName.restype = ctypes.POINTER(BNSymbol)
_BNGetSymbolByRawName.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNGetSymbolByRawName(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str],
nameSpace: ctypes.POINTER(BNNameSpace)
) -> Optional[ctypes.POINTER(BNSymbol)]:
result = _BNGetSymbolByRawName(view, cstr(name), nameSpace)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSymbolFullName
_BNGetSymbolFullName = core.BNGetSymbolFullName
_BNGetSymbolFullName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSymbolFullName.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNGetSymbolFullName(
sym: ctypes.POINTER(BNSymbol)
) -> Optional[Optional[str]]:
result = _BNGetSymbolFullName(sym)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetSymbolNameSpace
_BNGetSymbolNameSpace = core.BNGetSymbolNameSpace
_BNGetSymbolNameSpace.restype = BNNameSpace
_BNGetSymbolNameSpace.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNGetSymbolNameSpace(
sym: ctypes.POINTER(BNSymbol)
) -> BNNameSpace:
return _BNGetSymbolNameSpace(sym)
# -------------------------------------------------------
# _BNGetSymbolOrdinal
_BNGetSymbolOrdinal = core.BNGetSymbolOrdinal
_BNGetSymbolOrdinal.restype = ctypes.c_ulonglong
_BNGetSymbolOrdinal.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNGetSymbolOrdinal(
sym: ctypes.POINTER(BNSymbol)
) -> int:
return _BNGetSymbolOrdinal(sym)
# -------------------------------------------------------
# _BNGetSymbolRawBytes
_BNGetSymbolRawBytes = core.BNGetSymbolRawBytes
_BNGetSymbolRawBytes.restype = ctypes.c_void_p
_BNGetSymbolRawBytes.argtypes = [
ctypes.POINTER(BNSymbol),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetSymbolRawBytes(
sym: ctypes.POINTER(BNSymbol),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[Optional[ctypes.c_void_p]]:
result = _BNGetSymbolRawBytes(sym, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSymbolRawName
_BNGetSymbolRawName = core.BNGetSymbolRawName
_BNGetSymbolRawName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSymbolRawName.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNGetSymbolRawName(
sym: ctypes.POINTER(BNSymbol)
) -> Optional[Optional[str]]:
result = _BNGetSymbolRawName(sym)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetSymbolShortName
_BNGetSymbolShortName = core.BNGetSymbolShortName
_BNGetSymbolShortName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetSymbolShortName.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNGetSymbolShortName(
sym: ctypes.POINTER(BNSymbol)
) -> Optional[Optional[str]]:
result = _BNGetSymbolShortName(sym)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetSymbolType
_BNGetSymbolType = core.BNGetSymbolType
_BNGetSymbolType.restype = SymbolTypeEnum
_BNGetSymbolType.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNGetSymbolType(
sym: ctypes.POINTER(BNSymbol)
) -> SymbolType:
return _BNGetSymbolType(sym)
# -------------------------------------------------------
# _BNGetSymbols
_BNGetSymbols = core.BNGetSymbols
_BNGetSymbols.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbols.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNGetSymbols(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong),
nameSpace: ctypes.POINTER(BNNameSpace)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
result = _BNGetSymbols(view, count, nameSpace)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSymbolsByName
_BNGetSymbolsByName = core.BNGetSymbolsByName
_BNGetSymbolsByName.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsByName.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNGetSymbolsByName(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong),
nameSpace: ctypes.POINTER(BNNameSpace)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
result = _BNGetSymbolsByName(view, cstr(name), count, nameSpace)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSymbolsByRawName
_BNGetSymbolsByRawName = core.BNGetSymbolsByRawName
_BNGetSymbolsByRawName.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsByRawName.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNGetSymbolsByRawName(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong),
nameSpace: ctypes.POINTER(BNNameSpace)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
result = _BNGetSymbolsByRawName(view, cstr(name), count, nameSpace)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSymbolsInRange
_BNGetSymbolsInRange = core.BNGetSymbolsInRange
_BNGetSymbolsInRange.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNGetSymbolsInRange(
view: ctypes.POINTER(BNBinaryView),
start: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong),
nameSpace: ctypes.POINTER(BNNameSpace)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
result = _BNGetSymbolsInRange(view, start, len, count, nameSpace)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSymbolsOfType
_BNGetSymbolsOfType = core.BNGetSymbolsOfType
_BNGetSymbolsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsOfType.argtypes = [
ctypes.POINTER(BNBinaryView),
SymbolTypeEnum,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNGetSymbolsOfType(
view: ctypes.POINTER(BNBinaryView),
type: SymbolType,
count: ctypes.POINTER(ctypes.c_ulonglong),
nameSpace: ctypes.POINTER(BNNameSpace)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
result = _BNGetSymbolsOfType(view, type, count, nameSpace)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetSymbolsOfTypeInRange
_BNGetSymbolsOfTypeInRange = core.BNGetSymbolsOfTypeInRange
_BNGetSymbolsOfTypeInRange.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetSymbolsOfTypeInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
SymbolTypeEnum,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNGetSymbolsOfTypeInRange(
view: ctypes.POINTER(BNBinaryView),
type: SymbolType,
start: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong),
nameSpace: ctypes.POINTER(BNNameSpace)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
result = _BNGetSymbolsOfTypeInRange(view, type, start, len, count, nameSpace)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTag
_BNGetTag = core.BNGetTag
_BNGetTag.restype = ctypes.POINTER(BNTag)
_BNGetTag.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTag(
view: ctypes.POINTER(BNBinaryView),
tagId: Optional[str]
) -> Optional[ctypes.POINTER(BNTag)]:
result = _BNGetTag(view, cstr(tagId))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTagReferencesOfType
_BNGetTagReferencesOfType = core.BNGetTagReferencesOfType
_BNGetTagReferencesOfType.restype = ctypes.POINTER(BNTagReference)
_BNGetTagReferencesOfType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTagReferencesOfType(
view: ctypes.POINTER(BNBinaryView),
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetTagReferencesOfType(view, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTagReferencesOfTypeCount
_BNGetTagReferencesOfTypeCount = core.BNGetTagReferencesOfTypeCount
_BNGetTagReferencesOfTypeCount.restype = ctypes.c_ulonglong
_BNGetTagReferencesOfTypeCount.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNGetTagReferencesOfTypeCount(
view: ctypes.POINTER(BNBinaryView),
tagType: ctypes.POINTER(BNTagType)
) -> int:
return _BNGetTagReferencesOfTypeCount(view, tagType)
# -------------------------------------------------------
# _BNGetTagType
_BNGetTagType = core.BNGetTagType
_BNGetTagType.restype = ctypes.POINTER(BNTagType)
_BNGetTagType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTagType(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNTagType)]:
result = _BNGetTagType(view, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTagTypeById
_BNGetTagTypeById = core.BNGetTagTypeById
_BNGetTagTypeById.restype = ctypes.POINTER(BNTagType)
_BNGetTagTypeById.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTagTypeById(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str]
) -> Optional[ctypes.POINTER(BNTagType)]:
result = _BNGetTagTypeById(view, cstr(id))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTagTypeByIdWithType
_BNGetTagTypeByIdWithType = core.BNGetTagTypeByIdWithType
_BNGetTagTypeByIdWithType.restype = ctypes.POINTER(BNTagType)
_BNGetTagTypeByIdWithType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
TagTypeTypeEnum,
]
# noinspection PyPep8Naming
def BNGetTagTypeByIdWithType(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str],
type: TagTypeType
) -> Optional[ctypes.POINTER(BNTagType)]:
result = _BNGetTagTypeByIdWithType(view, cstr(id), type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTagTypeWithType
_BNGetTagTypeWithType = core.BNGetTagTypeWithType
_BNGetTagTypeWithType.restype = ctypes.POINTER(BNTagType)
_BNGetTagTypeWithType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
TagTypeTypeEnum,
]
# noinspection PyPep8Naming
def BNGetTagTypeWithType(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str],
type: TagTypeType
) -> Optional[ctypes.POINTER(BNTagType)]:
result = _BNGetTagTypeWithType(view, cstr(name), type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTagTypes
_BNGetTagTypes = core.BNGetTagTypes
_BNGetTagTypes.restype = ctypes.POINTER(ctypes.POINTER(BNTagType))
_BNGetTagTypes.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTagTypes(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTagType))]:
result = _BNGetTagTypes(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTemporaryFileContents
_BNGetTemporaryFileContents = core.BNGetTemporaryFileContents
_BNGetTemporaryFileContents.restype = ctypes.POINTER(BNDataBuffer)
_BNGetTemporaryFileContents.argtypes = [
ctypes.POINTER(BNTemporaryFile),
]
# noinspection PyPep8Naming
def BNGetTemporaryFileContents(
file: ctypes.POINTER(BNTemporaryFile)
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNGetTemporaryFileContents(file)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTemporaryFilePath
_BNGetTemporaryFilePath = core.BNGetTemporaryFilePath
_BNGetTemporaryFilePath.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTemporaryFilePath.argtypes = [
ctypes.POINTER(BNTemporaryFile),
]
# noinspection PyPep8Naming
def BNGetTemporaryFilePath(
file: ctypes.POINTER(BNTemporaryFile)
) -> Optional[Optional[str]]:
result = _BNGetTemporaryFilePath(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTextLineInput
_BNGetTextLineInput = core.BNGetTextLineInput
_BNGetTextLineInput.restype = ctypes.c_bool
_BNGetTextLineInput.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTextLineInput(
result: ctypes.POINTER(ctypes.c_char_p),
prompt: Optional[str],
title: Optional[str]
) -> bool:
return _BNGetTextLineInput(result, cstr(prompt), cstr(title))
# -------------------------------------------------------
# _BNGetTimeSinceLastUpdateCheck
_BNGetTimeSinceLastUpdateCheck = core.BNGetTimeSinceLastUpdateCheck
_BNGetTimeSinceLastUpdateCheck.restype = ctypes.c_ulonglong
_BNGetTimeSinceLastUpdateCheck.argtypes = [
]
# noinspection PyPep8Naming
def BNGetTimeSinceLastUpdateCheck(
) -> int:
return _BNGetTimeSinceLastUpdateCheck()
# -------------------------------------------------------
# _BNGetTransformByName
_BNGetTransformByName = core.BNGetTransformByName
_BNGetTransformByName.restype = ctypes.POINTER(BNTransform)
_BNGetTransformByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTransformByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNTransform)]:
result = _BNGetTransformByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTransformGroup
_BNGetTransformGroup = core.BNGetTransformGroup
_BNGetTransformGroup.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTransformGroup.argtypes = [
ctypes.POINTER(BNTransform),
]
# noinspection PyPep8Naming
def BNGetTransformGroup(
xform: ctypes.POINTER(BNTransform)
) -> Optional[Optional[str]]:
result = _BNGetTransformGroup(xform)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTransformLongName
_BNGetTransformLongName = core.BNGetTransformLongName
_BNGetTransformLongName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTransformLongName.argtypes = [
ctypes.POINTER(BNTransform),
]
# noinspection PyPep8Naming
def BNGetTransformLongName(
xform: ctypes.POINTER(BNTransform)
) -> Optional[Optional[str]]:
result = _BNGetTransformLongName(xform)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTransformName
_BNGetTransformName = core.BNGetTransformName
_BNGetTransformName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTransformName.argtypes = [
ctypes.POINTER(BNTransform),
]
# noinspection PyPep8Naming
def BNGetTransformName(
xform: ctypes.POINTER(BNTransform)
) -> Optional[Optional[str]]:
result = _BNGetTransformName(xform)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTransformParameterList
_BNGetTransformParameterList = core.BNGetTransformParameterList
_BNGetTransformParameterList.restype = ctypes.POINTER(BNTransformParameterInfo)
_BNGetTransformParameterList.argtypes = [
ctypes.POINTER(BNTransform),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTransformParameterList(
xform: ctypes.POINTER(BNTransform),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTransformParameterInfo)]:
result = _BNGetTransformParameterList(xform, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTransformType
_BNGetTransformType = core.BNGetTransformType
_BNGetTransformType.restype = TransformTypeEnum
_BNGetTransformType.argtypes = [
ctypes.POINTER(BNTransform),
]
# noinspection PyPep8Naming
def BNGetTransformType(
xform: ctypes.POINTER(BNTransform)
) -> TransformType:
return _BNGetTransformType(xform)
# -------------------------------------------------------
# _BNGetTransformTypeList
_BNGetTransformTypeList = core.BNGetTransformTypeList
_BNGetTransformTypeList.restype = ctypes.POINTER(ctypes.POINTER(BNTransform))
_BNGetTransformTypeList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTransformTypeList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTransform))]:
result = _BNGetTransformTypeList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeAlignment
_BNGetTypeAlignment = core.BNGetTypeAlignment
_BNGetTypeAlignment.restype = ctypes.c_ulonglong
_BNGetTypeAlignment.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeAlignment(
type: ctypes.POINTER(BNType)
) -> int:
return _BNGetTypeAlignment(type)
# -------------------------------------------------------
# _BNGetTypeAlternateName
_BNGetTypeAlternateName = core.BNGetTypeAlternateName
_BNGetTypeAlternateName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeAlternateName.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeAlternateName(
type: ctypes.POINTER(BNType)
) -> Optional[Optional[str]]:
result = _BNGetTypeAlternateName(type)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeAndName
_BNGetTypeAndName = core.BNGetTypeAndName
_BNGetTypeAndName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeAndName.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNQualifiedName),
TokenEscapingTypeEnum,
]
# noinspection PyPep8Naming
def BNGetTypeAndName(
type: ctypes.POINTER(BNType),
name: ctypes.POINTER(BNQualifiedName),
escaping: TokenEscapingType
) -> Optional[Optional[str]]:
result = _BNGetTypeAndName(type, name, escaping)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeArchiveAllSnapshotIds
_BNGetTypeArchiveAllSnapshotIds = core.BNGetTypeArchiveAllSnapshotIds
_BNGetTypeArchiveAllSnapshotIds.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveAllSnapshotIds.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveAllSnapshotIds(
archive: ctypes.POINTER(BNTypeArchive),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeArchiveAllSnapshotIds(archive, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveCurrentSnapshotId
_BNGetTypeArchiveCurrentSnapshotId = core.BNGetTypeArchiveCurrentSnapshotId
_BNGetTypeArchiveCurrentSnapshotId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeArchiveCurrentSnapshotId.argtypes = [
ctypes.POINTER(BNTypeArchive),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveCurrentSnapshotId(
archive: ctypes.POINTER(BNTypeArchive)
) -> Optional[Optional[str]]:
result = _BNGetTypeArchiveCurrentSnapshotId(archive)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeArchiveId
_BNGetTypeArchiveId = core.BNGetTypeArchiveId
_BNGetTypeArchiveId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeArchiveId.argtypes = [
ctypes.POINTER(BNTypeArchive),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveId(
archive: ctypes.POINTER(BNTypeArchive)
) -> Optional[Optional[str]]:
result = _BNGetTypeArchiveId(archive)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeArchiveIncomingDirectTypeReferences
_BNGetTypeArchiveIncomingDirectTypeReferences = core.BNGetTypeArchiveIncomingDirectTypeReferences
_BNGetTypeArchiveIncomingDirectTypeReferences.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveIncomingDirectTypeReferences.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveIncomingDirectTypeReferences(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str],
snapshot: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeArchiveIncomingDirectTypeReferences(archive, cstr(id), cstr(snapshot), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveIncomingRecursiveTypeReferences
_BNGetTypeArchiveIncomingRecursiveTypeReferences = core.BNGetTypeArchiveIncomingRecursiveTypeReferences
_BNGetTypeArchiveIncomingRecursiveTypeReferences.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveIncomingRecursiveTypeReferences.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveIncomingRecursiveTypeReferences(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str],
snapshot: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeArchiveIncomingRecursiveTypeReferences(archive, cstr(id), cstr(snapshot), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveOutgoingDirectTypeReferences
_BNGetTypeArchiveOutgoingDirectTypeReferences = core.BNGetTypeArchiveOutgoingDirectTypeReferences
_BNGetTypeArchiveOutgoingDirectTypeReferences.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveOutgoingDirectTypeReferences.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveOutgoingDirectTypeReferences(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str],
snapshot: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeArchiveOutgoingDirectTypeReferences(archive, cstr(id), cstr(snapshot), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveOutgoingRecursiveTypeReferences
_BNGetTypeArchiveOutgoingRecursiveTypeReferences = core.BNGetTypeArchiveOutgoingRecursiveTypeReferences
_BNGetTypeArchiveOutgoingRecursiveTypeReferences.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveOutgoingRecursiveTypeReferences.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveOutgoingRecursiveTypeReferences(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str],
snapshot: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeArchiveOutgoingRecursiveTypeReferences(archive, cstr(id), cstr(snapshot), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchivePath
_BNGetTypeArchivePath = core.BNGetTypeArchivePath
_BNGetTypeArchivePath.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeArchivePath.argtypes = [
ctypes.POINTER(BNTypeArchive),
]
# noinspection PyPep8Naming
def BNGetTypeArchivePath(
archive: ctypes.POINTER(BNTypeArchive)
) -> Optional[Optional[str]]:
result = _BNGetTypeArchivePath(archive)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeArchivePlatform
_BNGetTypeArchivePlatform = core.BNGetTypeArchivePlatform
_BNGetTypeArchivePlatform.restype = ctypes.POINTER(BNPlatform)
_BNGetTypeArchivePlatform.argtypes = [
ctypes.POINTER(BNTypeArchive),
]
# noinspection PyPep8Naming
def BNGetTypeArchivePlatform(
archive: ctypes.POINTER(BNTypeArchive)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNGetTypeArchivePlatform(archive)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveSnapshotChildIds
_BNGetTypeArchiveSnapshotChildIds = core.BNGetTypeArchiveSnapshotChildIds
_BNGetTypeArchiveSnapshotChildIds.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveSnapshotChildIds.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveSnapshotChildIds(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeArchiveSnapshotChildIds(archive, cstr(id), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveSnapshotParentIds
_BNGetTypeArchiveSnapshotParentIds = core.BNGetTypeArchiveSnapshotParentIds
_BNGetTypeArchiveSnapshotParentIds.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveSnapshotParentIds.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveSnapshotParentIds(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeArchiveSnapshotParentIds(archive, cstr(id), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveTypeById
_BNGetTypeArchiveTypeById = core.BNGetTypeArchiveTypeById
_BNGetTypeArchiveTypeById.restype = ctypes.POINTER(BNType)
_BNGetTypeArchiveTypeById.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTypeArchiveTypeById(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str],
snapshot: Optional[str]
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetTypeArchiveTypeById(archive, cstr(id), cstr(snapshot))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveTypeByName
_BNGetTypeArchiveTypeByName = core.BNGetTypeArchiveTypeByName
_BNGetTypeArchiveTypeByName.restype = ctypes.POINTER(BNType)
_BNGetTypeArchiveTypeByName.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.POINTER(BNQualifiedName),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTypeArchiveTypeByName(
archive: ctypes.POINTER(BNTypeArchive),
name: ctypes.POINTER(BNQualifiedName),
snapshot: Optional[str]
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetTypeArchiveTypeByName(archive, name, cstr(snapshot))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveTypeContainer
_BNGetTypeArchiveTypeContainer = core.BNGetTypeArchiveTypeContainer
_BNGetTypeArchiveTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetTypeArchiveTypeContainer.argtypes = [
ctypes.POINTER(BNTypeArchive),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveTypeContainer(
archive: ctypes.POINTER(BNTypeArchive)
) -> Optional[ctypes.POINTER(BNTypeContainer)]:
result = _BNGetTypeArchiveTypeContainer(archive)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveTypeId
_BNGetTypeArchiveTypeId = core.BNGetTypeArchiveTypeId
_BNGetTypeArchiveTypeId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeArchiveTypeId.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.POINTER(BNQualifiedName),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTypeArchiveTypeId(
archive: ctypes.POINTER(BNTypeArchive),
name: ctypes.POINTER(BNQualifiedName),
snapshot: Optional[str]
) -> Optional[Optional[str]]:
result = _BNGetTypeArchiveTypeId(archive, name, cstr(snapshot))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeArchiveTypeIds
_BNGetTypeArchiveTypeIds = core.BNGetTypeArchiveTypeIds
_BNGetTypeArchiveTypeIds.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeArchiveTypeIds.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveTypeIds(
archive: ctypes.POINTER(BNTypeArchive),
snapshot: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeArchiveTypeIds(archive, cstr(snapshot), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveTypeName
_BNGetTypeArchiveTypeName = core.BNGetTypeArchiveTypeName
_BNGetTypeArchiveTypeName.restype = BNQualifiedName
_BNGetTypeArchiveTypeName.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTypeArchiveTypeName(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str],
snapshot: Optional[str]
) -> BNQualifiedName:
return _BNGetTypeArchiveTypeName(archive, cstr(id), cstr(snapshot))
# -------------------------------------------------------
# _BNGetTypeArchiveTypeNames
_BNGetTypeArchiveTypeNames = core.BNGetTypeArchiveTypeNames
_BNGetTypeArchiveTypeNames.restype = ctypes.POINTER(BNQualifiedName)
_BNGetTypeArchiveTypeNames.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveTypeNames(
archive: ctypes.POINTER(BNTypeArchive),
snapshot: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedName)]:
result = _BNGetTypeArchiveTypeNames(archive, cstr(snapshot), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeArchiveTypeNamesAndIds
_BNGetTypeArchiveTypeNamesAndIds = core.BNGetTypeArchiveTypeNamesAndIds
_BNGetTypeArchiveTypeNamesAndIds.restype = ctypes.c_bool
_BNGetTypeArchiveTypeNamesAndIds.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveTypeNamesAndIds(
archive: ctypes.POINTER(BNTypeArchive),
snapshot: Optional[str],
names: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
ids: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetTypeArchiveTypeNamesAndIds(archive, cstr(snapshot), names, ids, count)
# -------------------------------------------------------
# _BNGetTypeArchiveTypes
_BNGetTypeArchiveTypes = core.BNGetTypeArchiveTypes
_BNGetTypeArchiveTypes.restype = ctypes.POINTER(BNQualifiedNameTypeAndId)
_BNGetTypeArchiveTypes.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeArchiveTypes(
archive: ctypes.POINTER(BNTypeArchive),
snapshot: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedNameTypeAndId)]:
result = _BNGetTypeArchiveTypes(archive, cstr(snapshot), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeBuilderAlignment
_BNGetTypeBuilderAlignment = core.BNGetTypeBuilderAlignment
_BNGetTypeBuilderAlignment.restype = ctypes.c_ulonglong
_BNGetTypeBuilderAlignment.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderAlignment(
type: ctypes.POINTER(BNTypeBuilder)
) -> int:
return _BNGetTypeBuilderAlignment(type)
# -------------------------------------------------------
# _BNGetTypeBuilderAlternateName
_BNGetTypeBuilderAlternateName = core.BNGetTypeBuilderAlternateName
_BNGetTypeBuilderAlternateName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderAlternateName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderAlternateName(
type: ctypes.POINTER(BNTypeBuilder)
) -> Optional[Optional[str]]:
result = _BNGetTypeBuilderAlternateName(type)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeBuilderCallingConvention
_BNGetTypeBuilderCallingConvention = core.BNGetTypeBuilderCallingConvention
_BNGetTypeBuilderCallingConvention.restype = BNCallingConventionWithConfidence
_BNGetTypeBuilderCallingConvention.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderCallingConvention(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNCallingConventionWithConfidence:
return _BNGetTypeBuilderCallingConvention(type)
# -------------------------------------------------------
# _BNGetTypeBuilderChildType
_BNGetTypeBuilderChildType = core.BNGetTypeBuilderChildType
_BNGetTypeBuilderChildType.restype = BNTypeWithConfidence
_BNGetTypeBuilderChildType.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderChildType(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNTypeWithConfidence:
return _BNGetTypeBuilderChildType(type)
# -------------------------------------------------------
# _BNGetTypeBuilderClass
_BNGetTypeBuilderClass = core.BNGetTypeBuilderClass
_BNGetTypeBuilderClass.restype = TypeClassEnum
_BNGetTypeBuilderClass.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderClass(
type: ctypes.POINTER(BNTypeBuilder)
) -> TypeClass:
return _BNGetTypeBuilderClass(type)
# -------------------------------------------------------
# _BNGetTypeBuilderElementCount
_BNGetTypeBuilderElementCount = core.BNGetTypeBuilderElementCount
_BNGetTypeBuilderElementCount.restype = ctypes.c_ulonglong
_BNGetTypeBuilderElementCount.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderElementCount(
type: ctypes.POINTER(BNTypeBuilder)
) -> int:
return _BNGetTypeBuilderElementCount(type)
# -------------------------------------------------------
# _BNGetTypeBuilderEnumeration
_BNGetTypeBuilderEnumeration = core.BNGetTypeBuilderEnumeration
_BNGetTypeBuilderEnumeration.restype = ctypes.POINTER(BNEnumeration)
_BNGetTypeBuilderEnumeration.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderEnumeration(
type: ctypes.POINTER(BNTypeBuilder)
) -> Optional[ctypes.POINTER(BNEnumeration)]:
result = _BNGetTypeBuilderEnumeration(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeBuilderNamedTypeReference
_BNGetTypeBuilderNamedTypeReference = core.BNGetTypeBuilderNamedTypeReference
_BNGetTypeBuilderNamedTypeReference.restype = ctypes.POINTER(BNNamedTypeReference)
_BNGetTypeBuilderNamedTypeReference.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderNamedTypeReference(
type: ctypes.POINTER(BNTypeBuilder)
) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
result = _BNGetTypeBuilderNamedTypeReference(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeBuilderOffset
_BNGetTypeBuilderOffset = core.BNGetTypeBuilderOffset
_BNGetTypeBuilderOffset.restype = ctypes.c_ulonglong
_BNGetTypeBuilderOffset.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderOffset(
type: ctypes.POINTER(BNTypeBuilder)
) -> int:
return _BNGetTypeBuilderOffset(type)
# -------------------------------------------------------
# _BNGetTypeBuilderParameters
_BNGetTypeBuilderParameters = core.BNGetTypeBuilderParameters
_BNGetTypeBuilderParameters.restype = ctypes.POINTER(BNFunctionParameter)
_BNGetTypeBuilderParameters.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderParameters(
type: ctypes.POINTER(BNTypeBuilder),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNFunctionParameter)]:
result = _BNGetTypeBuilderParameters(type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeBuilderStackAdjustment
_BNGetTypeBuilderStackAdjustment = core.BNGetTypeBuilderStackAdjustment
_BNGetTypeBuilderStackAdjustment.restype = BNOffsetWithConfidence
_BNGetTypeBuilderStackAdjustment.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderStackAdjustment(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNOffsetWithConfidence:
return _BNGetTypeBuilderStackAdjustment(type)
# -------------------------------------------------------
# _BNGetTypeBuilderString
_BNGetTypeBuilderString = core.BNGetTypeBuilderString
_BNGetTypeBuilderString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderString.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderString(
type: ctypes.POINTER(BNTypeBuilder),
platform: ctypes.POINTER(BNPlatform)
) -> Optional[Optional[str]]:
result = _BNGetTypeBuilderString(type, platform)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeBuilderStringAfterName
_BNGetTypeBuilderStringAfterName = core.BNGetTypeBuilderStringAfterName
_BNGetTypeBuilderStringAfterName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderStringAfterName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderStringAfterName(
type: ctypes.POINTER(BNTypeBuilder),
platform: ctypes.POINTER(BNPlatform)
) -> Optional[Optional[str]]:
result = _BNGetTypeBuilderStringAfterName(type, platform)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeBuilderStringBeforeName
_BNGetTypeBuilderStringBeforeName = core.BNGetTypeBuilderStringBeforeName
_BNGetTypeBuilderStringBeforeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderStringBeforeName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderStringBeforeName(
type: ctypes.POINTER(BNTypeBuilder),
platform: ctypes.POINTER(BNPlatform)
) -> Optional[Optional[str]]:
result = _BNGetTypeBuilderStringBeforeName(type, platform)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeBuilderStructure
_BNGetTypeBuilderStructure = core.BNGetTypeBuilderStructure
_BNGetTypeBuilderStructure.restype = ctypes.POINTER(BNStructure)
_BNGetTypeBuilderStructure.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderStructure(
type: ctypes.POINTER(BNTypeBuilder)
) -> Optional[ctypes.POINTER(BNStructure)]:
result = _BNGetTypeBuilderStructure(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeBuilderTokens
_BNGetTypeBuilderTokens = core.BNGetTypeBuilderTokens
_BNGetTypeBuilderTokens.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeBuilderTokens.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNPlatform),
ctypes.c_ubyte,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderTokens(
type: ctypes.POINTER(BNTypeBuilder),
platform: ctypes.POINTER(BNPlatform),
baseConfidence: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetTypeBuilderTokens(type, platform, baseConfidence, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeBuilderTokensAfterName
_BNGetTypeBuilderTokensAfterName = core.BNGetTypeBuilderTokensAfterName
_BNGetTypeBuilderTokensAfterName.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeBuilderTokensAfterName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNPlatform),
ctypes.c_ubyte,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderTokensAfterName(
type: ctypes.POINTER(BNTypeBuilder),
platform: ctypes.POINTER(BNPlatform),
baseConfidence: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetTypeBuilderTokensAfterName(type, platform, baseConfidence, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeBuilderTokensBeforeName
_BNGetTypeBuilderTokensBeforeName = core.BNGetTypeBuilderTokensBeforeName
_BNGetTypeBuilderTokensBeforeName.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeBuilderTokensBeforeName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNPlatform),
ctypes.c_ubyte,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderTokensBeforeName(
type: ctypes.POINTER(BNTypeBuilder),
platform: ctypes.POINTER(BNPlatform),
baseConfidence: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetTypeBuilderTokensBeforeName(type, platform, baseConfidence, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeBuilderTypeAndName
_BNGetTypeBuilderTypeAndName = core.BNGetTypeBuilderTypeAndName
_BNGetTypeBuilderTypeAndName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeBuilderTypeAndName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderTypeAndName(
type: ctypes.POINTER(BNTypeBuilder),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[Optional[str]]:
result = _BNGetTypeBuilderTypeAndName(type, name)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeBuilderWidth
_BNGetTypeBuilderWidth = core.BNGetTypeBuilderWidth
_BNGetTypeBuilderWidth.restype = ctypes.c_ulonglong
_BNGetTypeBuilderWidth.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeBuilderWidth(
type: ctypes.POINTER(BNTypeBuilder)
) -> int:
return _BNGetTypeBuilderWidth(type)
# -------------------------------------------------------
# _BNGetTypeCallingConvention
_BNGetTypeCallingConvention = core.BNGetTypeCallingConvention
_BNGetTypeCallingConvention.restype = BNCallingConventionWithConfidence
_BNGetTypeCallingConvention.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeCallingConvention(
type: ctypes.POINTER(BNType)
) -> BNCallingConventionWithConfidence:
return _BNGetTypeCallingConvention(type)
# -------------------------------------------------------
# _BNGetTypeClass
_BNGetTypeClass = core.BNGetTypeClass
_BNGetTypeClass.restype = TypeClassEnum
_BNGetTypeClass.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeClass(
type: ctypes.POINTER(BNType)
) -> TypeClass:
return _BNGetTypeClass(type)
# -------------------------------------------------------
# _BNGetTypeElementCount
_BNGetTypeElementCount = core.BNGetTypeElementCount
_BNGetTypeElementCount.restype = ctypes.c_ulonglong
_BNGetTypeElementCount.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeElementCount(
type: ctypes.POINTER(BNType)
) -> int:
return _BNGetTypeElementCount(type)
# -------------------------------------------------------
# _BNGetTypeEnumeration
_BNGetTypeEnumeration = core.BNGetTypeEnumeration
_BNGetTypeEnumeration.restype = ctypes.POINTER(BNEnumeration)
_BNGetTypeEnumeration.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeEnumeration(
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNEnumeration)]:
result = _BNGetTypeEnumeration(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeLibraryAlternateNames
_BNGetTypeLibraryAlternateNames = core.BNGetTypeLibraryAlternateNames
_BNGetTypeLibraryAlternateNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeLibraryAlternateNames.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryAlternateNames(
lib: ctypes.POINTER(BNTypeLibrary),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeLibraryAlternateNames(lib, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeLibraryArchitecture
_BNGetTypeLibraryArchitecture = core.BNGetTypeLibraryArchitecture
_BNGetTypeLibraryArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNGetTypeLibraryArchitecture.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryArchitecture(
lib: ctypes.POINTER(BNTypeLibrary)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNGetTypeLibraryArchitecture(lib)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeLibraryDependencyName
_BNGetTypeLibraryDependencyName = core.BNGetTypeLibraryDependencyName
_BNGetTypeLibraryDependencyName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeLibraryDependencyName.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryDependencyName(
lib: ctypes.POINTER(BNTypeLibrary)
) -> Optional[Optional[str]]:
result = _BNGetTypeLibraryDependencyName(lib)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeLibraryGuid
_BNGetTypeLibraryGuid = core.BNGetTypeLibraryGuid
_BNGetTypeLibraryGuid.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeLibraryGuid.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryGuid(
lib: ctypes.POINTER(BNTypeLibrary)
) -> Optional[Optional[str]]:
result = _BNGetTypeLibraryGuid(lib)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeLibraryName
_BNGetTypeLibraryName = core.BNGetTypeLibraryName
_BNGetTypeLibraryName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeLibraryName.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryName(
lib: ctypes.POINTER(BNTypeLibrary)
) -> Optional[Optional[str]]:
result = _BNGetTypeLibraryName(lib)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeLibraryNamedObject
_BNGetTypeLibraryNamedObject = core.BNGetTypeLibraryNamedObject
_BNGetTypeLibraryNamedObject.restype = ctypes.POINTER(BNType)
_BNGetTypeLibraryNamedObject.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryNamedObject(
lib: ctypes.POINTER(BNTypeLibrary),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetTypeLibraryNamedObject(lib, name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeLibraryNamedObjects
_BNGetTypeLibraryNamedObjects = core.BNGetTypeLibraryNamedObjects
_BNGetTypeLibraryNamedObjects.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetTypeLibraryNamedObjects.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryNamedObjects(
lib: ctypes.POINTER(BNTypeLibrary),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
result = _BNGetTypeLibraryNamedObjects(lib, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeLibraryNamedType
_BNGetTypeLibraryNamedType = core.BNGetTypeLibraryNamedType
_BNGetTypeLibraryNamedType.restype = ctypes.POINTER(BNType)
_BNGetTypeLibraryNamedType.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryNamedType(
lib: ctypes.POINTER(BNTypeLibrary),
name: ctypes.POINTER(BNQualifiedName)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNGetTypeLibraryNamedType(lib, name)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeLibraryNamedTypes
_BNGetTypeLibraryNamedTypes = core.BNGetTypeLibraryNamedTypes
_BNGetTypeLibraryNamedTypes.restype = ctypes.POINTER(BNQualifiedNameAndType)
_BNGetTypeLibraryNamedTypes.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryNamedTypes(
lib: ctypes.POINTER(BNTypeLibrary),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNQualifiedNameAndType)]:
result = _BNGetTypeLibraryNamedTypes(lib, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeLibraryPlatforms
_BNGetTypeLibraryPlatforms = core.BNGetTypeLibraryPlatforms
_BNGetTypeLibraryPlatforms.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetTypeLibraryPlatforms.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryPlatforms(
lib: ctypes.POINTER(BNTypeLibrary),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetTypeLibraryPlatforms(lib, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeLibraryTypeContainer
_BNGetTypeLibraryTypeContainer = core.BNGetTypeLibraryTypeContainer
_BNGetTypeLibraryTypeContainer.restype = ctypes.POINTER(BNTypeContainer)
_BNGetTypeLibraryTypeContainer.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNGetTypeLibraryTypeContainer(
lib: ctypes.POINTER(BNTypeLibrary)
) -> Optional[ctypes.POINTER(BNTypeContainer)]:
result = _BNGetTypeLibraryTypeContainer(lib)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeLines
_BNGetTypeLines = core.BNGetTypeLines
_BNGetTypeLines.restype = ctypes.POINTER(BNTypeDefinitionLine)
_BNGetTypeLines.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNTypeContainer),
ctypes.c_char_p,
ctypes.c_int,
ctypes.c_bool,
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeLines(
type: ctypes.POINTER(BNType),
types: ctypes.POINTER(BNTypeContainer),
name: Optional[str],
lineWidth: int,
collapsed: bool,
escaping: TokenEscapingType,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeDefinitionLine)]:
result = _BNGetTypeLines(type, types, cstr(name), lineWidth, collapsed, escaping, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeNamedTypeReference
_BNGetTypeNamedTypeReference = core.BNGetTypeNamedTypeReference
_BNGetTypeNamedTypeReference.restype = ctypes.POINTER(BNNamedTypeReference)
_BNGetTypeNamedTypeReference.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeNamedTypeReference(
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
result = _BNGetTypeNamedTypeReference(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeOffset
_BNGetTypeOffset = core.BNGetTypeOffset
_BNGetTypeOffset.restype = ctypes.c_ulonglong
_BNGetTypeOffset.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeOffset(
type: ctypes.POINTER(BNType)
) -> int:
return _BNGetTypeOffset(type)
# -------------------------------------------------------
# _BNGetTypeParameters
_BNGetTypeParameters = core.BNGetTypeParameters
_BNGetTypeParameters.restype = ctypes.POINTER(BNFunctionParameter)
_BNGetTypeParameters.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeParameters(
type: ctypes.POINTER(BNType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNFunctionParameter)]:
result = _BNGetTypeParameters(type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeParserByName
_BNGetTypeParserByName = core.BNGetTypeParserByName
_BNGetTypeParserByName.restype = ctypes.POINTER(BNTypeParser)
_BNGetTypeParserByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTypeParserByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeParser)]:
result = _BNGetTypeParserByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeParserList
_BNGetTypeParserList = core.BNGetTypeParserList
_BNGetTypeParserList.restype = ctypes.POINTER(ctypes.POINTER(BNTypeParser))
_BNGetTypeParserList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeParserList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypeParser))]:
result = _BNGetTypeParserList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeParserName
_BNGetTypeParserName = core.BNGetTypeParserName
_BNGetTypeParserName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeParserName.argtypes = [
ctypes.POINTER(BNTypeParser),
]
# noinspection PyPep8Naming
def BNGetTypeParserName(
parser: ctypes.POINTER(BNTypeParser)
) -> Optional[Optional[str]]:
result = _BNGetTypeParserName(parser)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeParserOptionText
_BNGetTypeParserOptionText = core.BNGetTypeParserOptionText
_BNGetTypeParserOptionText.restype = ctypes.c_bool
_BNGetTypeParserOptionText.argtypes = [
ctypes.POINTER(BNTypeParser),
TypeParserOptionEnum,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNGetTypeParserOptionText(
parser: ctypes.POINTER(BNTypeParser),
option: TypeParserOption,
value: Optional[str],
result: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNGetTypeParserOptionText(parser, option, cstr(value), result)
# -------------------------------------------------------
# _BNGetTypePrinterByName
_BNGetTypePrinterByName = core.BNGetTypePrinterByName
_BNGetTypePrinterByName.restype = ctypes.POINTER(BNTypePrinter)
_BNGetTypePrinterByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetTypePrinterByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNTypePrinter)]:
result = _BNGetTypePrinterByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypePrinterList
_BNGetTypePrinterList = core.BNGetTypePrinterList
_BNGetTypePrinterList.restype = ctypes.POINTER(ctypes.POINTER(BNTypePrinter))
_BNGetTypePrinterList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypePrinterList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTypePrinter))]:
result = _BNGetTypePrinterList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypePrinterName
_BNGetTypePrinterName = core.BNGetTypePrinterName
_BNGetTypePrinterName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypePrinterName.argtypes = [
ctypes.POINTER(BNTypePrinter),
]
# noinspection PyPep8Naming
def BNGetTypePrinterName(
printer: ctypes.POINTER(BNTypePrinter)
) -> Optional[Optional[str]]:
result = _BNGetTypePrinterName(printer)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypePrinterTypeLines
_BNGetTypePrinterTypeLines = core.BNGetTypePrinterTypeLines
_BNGetTypePrinterTypeLines.restype = ctypes.c_bool
_BNGetTypePrinterTypeLines.argtypes = [
ctypes.POINTER(BNTypePrinter),
ctypes.POINTER(BNType),
ctypes.POINTER(BNTypeContainer),
ctypes.POINTER(BNQualifiedName),
ctypes.c_int,
ctypes.c_bool,
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.POINTER(BNTypeDefinitionLine)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypePrinterTypeLines(
printer: ctypes.POINTER(BNTypePrinter),
type: ctypes.POINTER(BNType),
types: ctypes.POINTER(BNTypeContainer),
name: ctypes.POINTER(BNQualifiedName),
lineWidth: int,
collapsed: bool,
escaping: TokenEscapingType,
result: ctypes.POINTER(ctypes.POINTER(BNTypeDefinitionLine)),
resultCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetTypePrinterTypeLines(printer, type, types, name, lineWidth, collapsed, escaping, result, resultCount)
# -------------------------------------------------------
# _BNGetTypePrinterTypeString
_BNGetTypePrinterTypeString = core.BNGetTypePrinterTypeString
_BNGetTypePrinterTypeString.restype = ctypes.c_bool
_BNGetTypePrinterTypeString.argtypes = [
ctypes.POINTER(BNTypePrinter),
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNQualifiedName),
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNGetTypePrinterTypeString(
printer: ctypes.POINTER(BNTypePrinter),
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
name: ctypes.POINTER(BNQualifiedName),
escaping: TokenEscapingType,
result: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNGetTypePrinterTypeString(printer, type, platform, name, escaping, result)
# -------------------------------------------------------
# _BNGetTypePrinterTypeStringAfterName
_BNGetTypePrinterTypeStringAfterName = core.BNGetTypePrinterTypeStringAfterName
_BNGetTypePrinterTypeStringAfterName.restype = ctypes.c_bool
_BNGetTypePrinterTypeStringAfterName.argtypes = [
ctypes.POINTER(BNTypePrinter),
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNGetTypePrinterTypeStringAfterName(
printer: ctypes.POINTER(BNTypePrinter),
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
escaping: TokenEscapingType,
result: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNGetTypePrinterTypeStringAfterName(printer, type, platform, escaping, result)
# -------------------------------------------------------
# _BNGetTypePrinterTypeStringBeforeName
_BNGetTypePrinterTypeStringBeforeName = core.BNGetTypePrinterTypeStringBeforeName
_BNGetTypePrinterTypeStringBeforeName.restype = ctypes.c_bool
_BNGetTypePrinterTypeStringBeforeName.argtypes = [
ctypes.POINTER(BNTypePrinter),
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNGetTypePrinterTypeStringBeforeName(
printer: ctypes.POINTER(BNTypePrinter),
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
escaping: TokenEscapingType,
result: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNGetTypePrinterTypeStringBeforeName(printer, type, platform, escaping, result)
# -------------------------------------------------------
# _BNGetTypePrinterTypeTokens
_BNGetTypePrinterTypeTokens = core.BNGetTypePrinterTypeTokens
_BNGetTypePrinterTypeTokens.restype = ctypes.c_bool
_BNGetTypePrinterTypeTokens.argtypes = [
ctypes.POINTER(BNTypePrinter),
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ubyte,
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypePrinterTypeTokens(
printer: ctypes.POINTER(BNTypePrinter),
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
name: ctypes.POINTER(BNQualifiedName),
baseConfidence: int,
escaping: TokenEscapingType,
result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
resultCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetTypePrinterTypeTokens(printer, type, platform, name, baseConfidence, escaping, result, resultCount)
# -------------------------------------------------------
# _BNGetTypePrinterTypeTokensAfterName
_BNGetTypePrinterTypeTokensAfterName = core.BNGetTypePrinterTypeTokensAfterName
_BNGetTypePrinterTypeTokensAfterName.restype = ctypes.c_bool
_BNGetTypePrinterTypeTokensAfterName.argtypes = [
ctypes.POINTER(BNTypePrinter),
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
ctypes.c_ubyte,
ctypes.POINTER(BNType),
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypePrinterTypeTokensAfterName(
printer: ctypes.POINTER(BNTypePrinter),
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
baseConfidence: int,
parentType: ctypes.POINTER(BNType),
escaping: TokenEscapingType,
result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
resultCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetTypePrinterTypeTokensAfterName(printer, type, platform, baseConfidence, parentType, escaping, result, resultCount)
# -------------------------------------------------------
# _BNGetTypePrinterTypeTokensBeforeName
_BNGetTypePrinterTypeTokensBeforeName = core.BNGetTypePrinterTypeTokensBeforeName
_BNGetTypePrinterTypeTokensBeforeName.restype = ctypes.c_bool
_BNGetTypePrinterTypeTokensBeforeName.argtypes = [
ctypes.POINTER(BNTypePrinter),
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
ctypes.c_ubyte,
ctypes.POINTER(BNType),
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypePrinterTypeTokensBeforeName(
printer: ctypes.POINTER(BNTypePrinter),
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
baseConfidence: int,
parentType: ctypes.POINTER(BNType),
escaping: TokenEscapingType,
result: ctypes.POINTER(ctypes.POINTER(BNInstructionTextToken)),
resultCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNGetTypePrinterTypeTokensBeforeName(printer, type, platform, baseConfidence, parentType, escaping, result, resultCount)
# -------------------------------------------------------
# _BNGetTypeReferenceBuilderClass
_BNGetTypeReferenceBuilderClass = core.BNGetTypeReferenceBuilderClass
_BNGetTypeReferenceBuilderClass.restype = NamedTypeReferenceClassEnum
_BNGetTypeReferenceBuilderClass.argtypes = [
ctypes.POINTER(BNNamedTypeReferenceBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeReferenceBuilderClass(
nt: ctypes.POINTER(BNNamedTypeReferenceBuilder)
) -> NamedTypeReferenceClass:
return _BNGetTypeReferenceBuilderClass(nt)
# -------------------------------------------------------
# _BNGetTypeReferenceBuilderId
_BNGetTypeReferenceBuilderId = core.BNGetTypeReferenceBuilderId
_BNGetTypeReferenceBuilderId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeReferenceBuilderId.argtypes = [
ctypes.POINTER(BNNamedTypeReferenceBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeReferenceBuilderId(
nt: ctypes.POINTER(BNNamedTypeReferenceBuilder)
) -> Optional[Optional[str]]:
result = _BNGetTypeReferenceBuilderId(nt)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeReferenceBuilderName
_BNGetTypeReferenceBuilderName = core.BNGetTypeReferenceBuilderName
_BNGetTypeReferenceBuilderName.restype = BNQualifiedName
_BNGetTypeReferenceBuilderName.argtypes = [
ctypes.POINTER(BNNamedTypeReferenceBuilder),
]
# noinspection PyPep8Naming
def BNGetTypeReferenceBuilderName(
nt: ctypes.POINTER(BNNamedTypeReferenceBuilder)
) -> BNQualifiedName:
return _BNGetTypeReferenceBuilderName(nt)
# -------------------------------------------------------
# _BNGetTypeReferenceClass
_BNGetTypeReferenceClass = core.BNGetTypeReferenceClass
_BNGetTypeReferenceClass.restype = NamedTypeReferenceClassEnum
_BNGetTypeReferenceClass.argtypes = [
ctypes.POINTER(BNNamedTypeReference),
]
# noinspection PyPep8Naming
def BNGetTypeReferenceClass(
nt: ctypes.POINTER(BNNamedTypeReference)
) -> NamedTypeReferenceClass:
return _BNGetTypeReferenceClass(nt)
# -------------------------------------------------------
# _BNGetTypeReferenceId
_BNGetTypeReferenceId = core.BNGetTypeReferenceId
_BNGetTypeReferenceId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeReferenceId.argtypes = [
ctypes.POINTER(BNNamedTypeReference),
]
# noinspection PyPep8Naming
def BNGetTypeReferenceId(
nt: ctypes.POINTER(BNNamedTypeReference)
) -> Optional[Optional[str]]:
result = _BNGetTypeReferenceId(nt)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeReferenceName
_BNGetTypeReferenceName = core.BNGetTypeReferenceName
_BNGetTypeReferenceName.restype = BNQualifiedName
_BNGetTypeReferenceName.argtypes = [
ctypes.POINTER(BNNamedTypeReference),
]
# noinspection PyPep8Naming
def BNGetTypeReferenceName(
nt: ctypes.POINTER(BNNamedTypeReference)
) -> BNQualifiedName:
return _BNGetTypeReferenceName(nt)
# -------------------------------------------------------
# _BNGetTypeReferencesForType
_BNGetTypeReferencesForType = core.BNGetTypeReferencesForType
_BNGetTypeReferencesForType.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetTypeReferencesForType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeReferencesForType(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
result = _BNGetTypeReferencesForType(view, type, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeReferencesForTypeField
_BNGetTypeReferencesForTypeField = core.BNGetTypeReferencesForTypeField
_BNGetTypeReferencesForTypeField.restype = ctypes.POINTER(BNTypeReferenceSource)
_BNGetTypeReferencesForTypeField.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeReferencesForTypeField(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
offset: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeReferenceSource)]:
result = _BNGetTypeReferencesForTypeField(view, type, offset, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeStackAdjustment
_BNGetTypeStackAdjustment = core.BNGetTypeStackAdjustment
_BNGetTypeStackAdjustment.restype = BNOffsetWithConfidence
_BNGetTypeStackAdjustment.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeStackAdjustment(
type: ctypes.POINTER(BNType)
) -> BNOffsetWithConfidence:
return _BNGetTypeStackAdjustment(type)
# -------------------------------------------------------
# _BNGetTypeString
_BNGetTypeString = core.BNGetTypeString
_BNGetTypeString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeString.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
TokenEscapingTypeEnum,
]
# noinspection PyPep8Naming
def BNGetTypeString(
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
escaping: TokenEscapingType
) -> Optional[Optional[str]]:
result = _BNGetTypeString(type, platform, escaping)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeStringAfterName
_BNGetTypeStringAfterName = core.BNGetTypeStringAfterName
_BNGetTypeStringAfterName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeStringAfterName.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
TokenEscapingTypeEnum,
]
# noinspection PyPep8Naming
def BNGetTypeStringAfterName(
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
escaping: TokenEscapingType
) -> Optional[Optional[str]]:
result = _BNGetTypeStringAfterName(type, platform, escaping)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeStringBeforeName
_BNGetTypeStringBeforeName = core.BNGetTypeStringBeforeName
_BNGetTypeStringBeforeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetTypeStringBeforeName.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
TokenEscapingTypeEnum,
]
# noinspection PyPep8Naming
def BNGetTypeStringBeforeName(
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
escaping: TokenEscapingType
) -> Optional[Optional[str]]:
result = _BNGetTypeStringBeforeName(type, platform, escaping)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetTypeStructure
_BNGetTypeStructure = core.BNGetTypeStructure
_BNGetTypeStructure.restype = ctypes.POINTER(BNStructure)
_BNGetTypeStructure.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeStructure(
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNStructure)]:
result = _BNGetTypeStructure(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeTokens
_BNGetTypeTokens = core.BNGetTypeTokens
_BNGetTypeTokens.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeTokens.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
ctypes.c_ubyte,
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeTokens(
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
baseConfidence: int,
escaping: TokenEscapingType,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetTypeTokens(type, platform, baseConfidence, escaping, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeTokensAfterName
_BNGetTypeTokensAfterName = core.BNGetTypeTokensAfterName
_BNGetTypeTokensAfterName.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeTokensAfterName.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
ctypes.c_ubyte,
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeTokensAfterName(
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
baseConfidence: int,
escaping: TokenEscapingType,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetTypeTokensAfterName(type, platform, baseConfidence, escaping, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeTokensBeforeName
_BNGetTypeTokensBeforeName = core.BNGetTypeTokensBeforeName
_BNGetTypeTokensBeforeName.restype = ctypes.POINTER(BNInstructionTextToken)
_BNGetTypeTokensBeforeName.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNPlatform),
ctypes.c_ubyte,
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypeTokensBeforeName(
type: ctypes.POINTER(BNType),
platform: ctypes.POINTER(BNPlatform),
baseConfidence: int,
escaping: TokenEscapingType,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNInstructionTextToken)]:
result = _BNGetTypeTokensBeforeName(type, platform, baseConfidence, escaping, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetTypeWidth
_BNGetTypeWidth = core.BNGetTypeWidth
_BNGetTypeWidth.restype = ctypes.c_ulonglong
_BNGetTypeWidth.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNGetTypeWidth(
type: ctypes.POINTER(BNType)
) -> int:
return _BNGetTypeWidth(type)
# -------------------------------------------------------
# _BNGetTypesReferenced
_BNGetTypesReferenced = core.BNGetTypesReferenced
_BNGetTypesReferenced.restype = ctypes.POINTER(BNTypeWithConfidence)
_BNGetTypesReferenced.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetTypesReferenced(
view: ctypes.POINTER(BNBinaryView),
type: ctypes.POINTER(BNQualifiedName),
offset: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTypeWithConfidence)]:
result = _BNGetTypesReferenced(view, type, offset, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUndoEntries
_BNGetUndoEntries = core.BNGetUndoEntries
_BNGetUndoEntries.restype = ctypes.POINTER(BNUndoEntry)
_BNGetUndoEntries.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUndoEntries(
file: ctypes.POINTER(BNFileMetadata),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNUndoEntry)]:
result = _BNGetUndoEntries(file, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUniqueIdentifierString
_BNGetUniqueIdentifierString = core.BNGetUniqueIdentifierString
_BNGetUniqueIdentifierString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUniqueIdentifierString.argtypes = [
]
# noinspection PyPep8Naming
def BNGetUniqueIdentifierString(
) -> Optional[Optional[str]]:
result = _BNGetUniqueIdentifierString()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetUniqueSectionNames
_BNGetUniqueSectionNames = core.BNGetUniqueSectionNames
_BNGetUniqueSectionNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNGetUniqueSectionNames.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNGetUniqueSectionNames(
view: ctypes.POINTER(BNBinaryView),
names: ctypes.POINTER(ctypes.c_char_p),
count: int
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNGetUniqueSectionNames(view, names, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUnresolvedIndirectBranches
_BNGetUnresolvedIndirectBranches = core.BNGetUnresolvedIndirectBranches
_BNGetUnresolvedIndirectBranches.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNGetUnresolvedIndirectBranches.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUnresolvedIndirectBranches(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNGetUnresolvedIndirectBranches(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUnresolvedStackAdjustmentGraph
_BNGetUnresolvedStackAdjustmentGraph = core.BNGetUnresolvedStackAdjustmentGraph
_BNGetUnresolvedStackAdjustmentGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNGetUnresolvedStackAdjustmentGraph.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetUnresolvedStackAdjustmentGraph(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNGetUnresolvedStackAdjustmentGraph(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUpdateChannelVersions
_BNGetUpdateChannelVersions = core.BNGetUpdateChannelVersions
_BNGetUpdateChannelVersions.restype = ctypes.POINTER(BNUpdateVersion)
_BNGetUpdateChannelVersions.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNGetUpdateChannelVersions(
channel: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong),
errors: ctypes.POINTER(ctypes.c_char_p)
) -> Optional[ctypes.POINTER(BNUpdateVersion)]:
result = _BNGetUpdateChannelVersions(cstr(channel), count, errors)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUpdateChannels
_BNGetUpdateChannels = core.BNGetUpdateChannels
_BNGetUpdateChannels.restype = ctypes.POINTER(BNUpdateChannel)
_BNGetUpdateChannels.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNGetUpdateChannels(
count: ctypes.POINTER(ctypes.c_ulonglong),
errors: ctypes.POINTER(ctypes.c_char_p)
) -> Optional[ctypes.POINTER(BNUpdateChannel)]:
result = _BNGetUpdateChannels(count, errors)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserAddressTagReferences
_BNGetUserAddressTagReferences = core.BNGetUserAddressTagReferences
_BNGetUserAddressTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetUserAddressTagReferences.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserAddressTagReferences(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetUserAddressTagReferences(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserAddressTags
_BNGetUserAddressTags = core.BNGetUserAddressTags
_BNGetUserAddressTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserAddressTags.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserAddressTags(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetUserAddressTags(func, arch, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserAddressTagsInRange
_BNGetUserAddressTagsInRange = core.BNGetUserAddressTagsInRange
_BNGetUserAddressTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetUserAddressTagsInRange.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserAddressTagsInRange(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
start: int,
end: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetUserAddressTagsInRange(func, arch, start, end, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserAddressTagsOfType
_BNGetUserAddressTagsOfType = core.BNGetUserAddressTagsOfType
_BNGetUserAddressTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserAddressTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserAddressTagsOfType(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetUserAddressTagsOfType(func, arch, addr, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserDataTagReferences
_BNGetUserDataTagReferences = core.BNGetUserDataTagReferences
_BNGetUserDataTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetUserDataTagReferences.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserDataTagReferences(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetUserDataTagReferences(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserDataTags
_BNGetUserDataTags = core.BNGetUserDataTags
_BNGetUserDataTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserDataTags.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserDataTags(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetUserDataTags(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserDataTagsInRange
_BNGetUserDataTagsInRange = core.BNGetUserDataTagsInRange
_BNGetUserDataTagsInRange.restype = ctypes.POINTER(BNTagReference)
_BNGetUserDataTagsInRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserDataTagsInRange(
view: ctypes.POINTER(BNBinaryView),
start: int,
end: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetUserDataTagsInRange(view, start, end, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserDataTagsOfType
_BNGetUserDataTagsOfType = core.BNGetUserDataTagsOfType
_BNGetUserDataTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserDataTagsOfType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserDataTagsOfType(
view: ctypes.POINTER(BNBinaryView),
addr: int,
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetUserDataTagsOfType(view, addr, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserDirectory
_BNGetUserDirectory = core.BNGetUserDirectory
_BNGetUserDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserDirectory.argtypes = [
]
# noinspection PyPep8Naming
def BNGetUserDirectory(
) -> Optional[Optional[str]]:
result = _BNGetUserDirectory()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetUserEmail
_BNGetUserEmail = core.BNGetUserEmail
_BNGetUserEmail.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserEmail.argtypes = [
ctypes.POINTER(BNUser),
]
# noinspection PyPep8Naming
def BNGetUserEmail(
user: ctypes.POINTER(BNUser)
) -> Optional[Optional[str]]:
result = _BNGetUserEmail(user)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetUserFunctionTagReferences
_BNGetUserFunctionTagReferences = core.BNGetUserFunctionTagReferences
_BNGetUserFunctionTagReferences.restype = ctypes.POINTER(BNTagReference)
_BNGetUserFunctionTagReferences.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserFunctionTagReferences(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNTagReference)]:
result = _BNGetUserFunctionTagReferences(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserFunctionTags
_BNGetUserFunctionTags = core.BNGetUserFunctionTags
_BNGetUserFunctionTags.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserFunctionTags.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserFunctionTags(
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetUserFunctionTags(func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserFunctionTagsOfType
_BNGetUserFunctionTagsOfType = core.BNGetUserFunctionTagsOfType
_BNGetUserFunctionTagsOfType.restype = ctypes.POINTER(ctypes.POINTER(BNTag))
_BNGetUserFunctionTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTagType),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUserFunctionTagsOfType(
func: ctypes.POINTER(BNFunction),
tagType: ctypes.POINTER(BNTagType),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNTag))]:
result = _BNGetUserFunctionTagsOfType(func, tagType, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetUserId
_BNGetUserId = core.BNGetUserId
_BNGetUserId.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserId.argtypes = [
ctypes.POINTER(BNUser),
]
# noinspection PyPep8Naming
def BNGetUserId(
user: ctypes.POINTER(BNUser)
) -> Optional[Optional[str]]:
result = _BNGetUserId(user)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetUserName
_BNGetUserName = core.BNGetUserName
_BNGetUserName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserName.argtypes = [
ctypes.POINTER(BNUser),
]
# noinspection PyPep8Naming
def BNGetUserName(
user: ctypes.POINTER(BNUser)
) -> Optional[Optional[str]]:
result = _BNGetUserName(user)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetUserPluginDirectory
_BNGetUserPluginDirectory = core.BNGetUserPluginDirectory
_BNGetUserPluginDirectory.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetUserPluginDirectory.argtypes = [
]
# noinspection PyPep8Naming
def BNGetUserPluginDirectory(
) -> Optional[Optional[str]]:
result = _BNGetUserPluginDirectory()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetUsers
_BNGetUsers = core.BNGetUsers
_BNGetUsers.restype = ctypes.POINTER(ctypes.POINTER(BNUser))
_BNGetUsers.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetUsers(
file: ctypes.POINTER(BNFileMetadata),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNUser))]:
result = _BNGetUsers(file, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommands
_BNGetValidPluginCommands = core.BNGetValidPluginCommands
_BNGetValidPluginCommands.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommands.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommands(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommands(view, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommandsForAddress
_BNGetValidPluginCommandsForAddress = core.BNGetValidPluginCommandsForAddress
_BNGetValidPluginCommandsForAddress.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommandsForAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommandsForAddress(view, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommandsForFunction
_BNGetValidPluginCommandsForFunction = core.BNGetValidPluginCommandsForFunction
_BNGetValidPluginCommandsForFunction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommandsForFunction(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommandsForFunction(view, func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommandsForHighLevelILFunction
_BNGetValidPluginCommandsForHighLevelILFunction = core.BNGetValidPluginCommandsForHighLevelILFunction
_BNGetValidPluginCommandsForHighLevelILFunction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForHighLevelILFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommandsForHighLevelILFunction(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNHighLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommandsForHighLevelILFunction(view, func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommandsForHighLevelILInstruction
_BNGetValidPluginCommandsForHighLevelILInstruction = core.BNGetValidPluginCommandsForHighLevelILInstruction
_BNGetValidPluginCommandsForHighLevelILInstruction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForHighLevelILInstruction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommandsForHighLevelILInstruction(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNHighLevelILFunction),
instr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommandsForHighLevelILInstruction(view, func, instr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommandsForLowLevelILFunction
_BNGetValidPluginCommandsForLowLevelILFunction = core.BNGetValidPluginCommandsForLowLevelILFunction
_BNGetValidPluginCommandsForLowLevelILFunction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForLowLevelILFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommandsForLowLevelILFunction(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNLowLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommandsForLowLevelILFunction(view, func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommandsForLowLevelILInstruction
_BNGetValidPluginCommandsForLowLevelILInstruction = core.BNGetValidPluginCommandsForLowLevelILInstruction
_BNGetValidPluginCommandsForLowLevelILInstruction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForLowLevelILInstruction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommandsForLowLevelILInstruction(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNLowLevelILFunction),
instr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommandsForLowLevelILInstruction(view, func, instr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommandsForMediumLevelILFunction
_BNGetValidPluginCommandsForMediumLevelILFunction = core.BNGetValidPluginCommandsForMediumLevelILFunction
_BNGetValidPluginCommandsForMediumLevelILFunction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommandsForMediumLevelILFunction(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNMediumLevelILFunction),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommandsForMediumLevelILFunction(view, func, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommandsForMediumLevelILInstruction
_BNGetValidPluginCommandsForMediumLevelILInstruction = core.BNGetValidPluginCommandsForMediumLevelILInstruction
_BNGetValidPluginCommandsForMediumLevelILInstruction.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForMediumLevelILInstruction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommandsForMediumLevelILInstruction(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommandsForMediumLevelILInstruction(view, func, instr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetValidPluginCommandsForRange
_BNGetValidPluginCommandsForRange = core.BNGetValidPluginCommandsForRange
_BNGetValidPluginCommandsForRange.restype = ctypes.POINTER(BNPluginCommand)
_BNGetValidPluginCommandsForRange.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetValidPluginCommandsForRange(
view: ctypes.POINTER(BNBinaryView),
addr: int,
len: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNPluginCommand)]:
result = _BNGetValidPluginCommandsForRange(view, addr, len, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetVariableName
_BNGetVariableName = core.BNGetVariableName
_BNGetVariableName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetVariableName.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNGetVariableName(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable)
) -> Optional[Optional[str]]:
result = _BNGetVariableName(func, var)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetVariableNameOrDefault
_BNGetVariableNameOrDefault = core.BNGetVariableNameOrDefault
_BNGetVariableNameOrDefault.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetVariableNameOrDefault.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNGetVariableNameOrDefault(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable)
) -> Optional[Optional[str]]:
result = _BNGetVariableNameOrDefault(func, var)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetVariableType
_BNGetVariableType = core.BNGetVariableType
_BNGetVariableType.restype = BNTypeWithConfidence
_BNGetVariableType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNGetVariableType(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable)
) -> BNTypeWithConfidence:
return _BNGetVariableType(func, var)
# -------------------------------------------------------
# _BNGetVariablesForParameters
_BNGetVariablesForParameters = core.BNGetVariablesForParameters
_BNGetVariablesForParameters.restype = ctypes.POINTER(BNVariable)
_BNGetVariablesForParameters.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(BNFunctionParameter),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_uint),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetVariablesForParameters(
cc: ctypes.POINTER(BNCallingConvention),
params: ctypes.POINTER(BNFunctionParameter),
paramCount: int,
permittedArgs: ctypes.POINTER(ctypes.c_uint),
permittedArgCount: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariable)]:
result = _BNGetVariablesForParameters(cc, params, paramCount, permittedArgs, permittedArgCount, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetVariablesForParametersDefaultPermittedArgs
_BNGetVariablesForParametersDefaultPermittedArgs = core.BNGetVariablesForParametersDefaultPermittedArgs
_BNGetVariablesForParametersDefaultPermittedArgs.restype = ctypes.POINTER(BNVariable)
_BNGetVariablesForParametersDefaultPermittedArgs.argtypes = [
ctypes.POINTER(BNCallingConvention),
ctypes.POINTER(BNFunctionParameter),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetVariablesForParametersDefaultPermittedArgs(
cc: ctypes.POINTER(BNCallingConvention),
params: ctypes.POINTER(BNFunctionParameter),
paramCount: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNVariable)]:
result = _BNGetVariablesForParametersDefaultPermittedArgs(cc, params, paramCount, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetVersionInfo
_BNGetVersionInfo = core.BNGetVersionInfo
_BNGetVersionInfo.restype = BNVersionInfo
_BNGetVersionInfo.argtypes = [
]
# noinspection PyPep8Naming
def BNGetVersionInfo(
) -> BNVersionInfo:
return _BNGetVersionInfo()
# -------------------------------------------------------
# _BNGetVersionString
_BNGetVersionString = core.BNGetVersionString
_BNGetVersionString.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetVersionString.argtypes = [
]
# noinspection PyPep8Naming
def BNGetVersionString(
) -> Optional[Optional[str]]:
result = _BNGetVersionString()
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetVerticalFlowGraphNodeMargin
_BNGetVerticalFlowGraphNodeMargin = core.BNGetVerticalFlowGraphNodeMargin
_BNGetVerticalFlowGraphNodeMargin.restype = ctypes.c_int
_BNGetVerticalFlowGraphNodeMargin.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNGetVerticalFlowGraphNodeMargin(
graph: ctypes.POINTER(BNFlowGraph)
) -> int:
return _BNGetVerticalFlowGraphNodeMargin(graph)
# -------------------------------------------------------
# _BNGetViewAddressSize
_BNGetViewAddressSize = core.BNGetViewAddressSize
_BNGetViewAddressSize.restype = ctypes.c_ulonglong
_BNGetViewAddressSize.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetViewAddressSize(
view: ctypes.POINTER(BNBinaryView)
) -> int:
return _BNGetViewAddressSize(view)
# -------------------------------------------------------
# _BNGetViewForFlowGraph
_BNGetViewForFlowGraph = core.BNGetViewForFlowGraph
_BNGetViewForFlowGraph.restype = ctypes.POINTER(BNBinaryView)
_BNGetViewForFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNGetViewForFlowGraph(
graph: ctypes.POINTER(BNFlowGraph)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNGetViewForFlowGraph(graph)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetViewLength
_BNGetViewLength = core.BNGetViewLength
_BNGetViewLength.restype = ctypes.c_ulonglong
_BNGetViewLength.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetViewLength(
view: ctypes.POINTER(BNBinaryView)
) -> int:
return _BNGetViewLength(view)
# -------------------------------------------------------
# _BNGetViewType
_BNGetViewType = core.BNGetViewType
_BNGetViewType.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetViewType.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetViewType(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[Optional[str]]:
result = _BNGetViewType(view)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetVisibleSymbols
_BNGetVisibleSymbols = core.BNGetVisibleSymbols
_BNGetVisibleSymbols.restype = ctypes.POINTER(ctypes.POINTER(BNSymbol))
_BNGetVisibleSymbols.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNNameSpace),
]
# noinspection PyPep8Naming
def BNGetVisibleSymbols(
view: ctypes.POINTER(BNBinaryView),
count: ctypes.POINTER(ctypes.c_ulonglong),
nameSpace: ctypes.POINTER(BNNameSpace)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNSymbol))]:
result = _BNGetVisibleSymbols(view, count, nameSpace)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetWebsocketProviderByName
_BNGetWebsocketProviderByName = core.BNGetWebsocketProviderByName
_BNGetWebsocketProviderByName.restype = ctypes.POINTER(BNWebsocketProvider)
_BNGetWebsocketProviderByName.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNGetWebsocketProviderByName(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNWebsocketProvider)]:
result = _BNGetWebsocketProviderByName(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetWebsocketProviderList
_BNGetWebsocketProviderList = core.BNGetWebsocketProviderList
_BNGetWebsocketProviderList.restype = ctypes.POINTER(ctypes.POINTER(BNWebsocketProvider))
_BNGetWebsocketProviderList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetWebsocketProviderList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNWebsocketProvider))]:
result = _BNGetWebsocketProviderList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetWebsocketProviderName
_BNGetWebsocketProviderName = core.BNGetWebsocketProviderName
_BNGetWebsocketProviderName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetWebsocketProviderName.argtypes = [
ctypes.POINTER(BNWebsocketProvider),
]
# noinspection PyPep8Naming
def BNGetWebsocketProviderName(
provider: ctypes.POINTER(BNWebsocketProvider)
) -> Optional[Optional[str]]:
result = _BNGetWebsocketProviderName(provider)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetWorkerThreadCount
_BNGetWorkerThreadCount = core.BNGetWorkerThreadCount
_BNGetWorkerThreadCount.restype = ctypes.c_ulonglong
_BNGetWorkerThreadCount.argtypes = [
]
# noinspection PyPep8Naming
def BNGetWorkerThreadCount(
) -> int:
return _BNGetWorkerThreadCount()
# -------------------------------------------------------
# _BNGetWorkflowForBinaryView
_BNGetWorkflowForBinaryView = core.BNGetWorkflowForBinaryView
_BNGetWorkflowForBinaryView.restype = ctypes.POINTER(BNWorkflow)
_BNGetWorkflowForBinaryView.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNGetWorkflowForBinaryView(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNWorkflow)]:
result = _BNGetWorkflowForBinaryView(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetWorkflowForFunction
_BNGetWorkflowForFunction = core.BNGetWorkflowForFunction
_BNGetWorkflowForFunction.restype = ctypes.POINTER(BNWorkflow)
_BNGetWorkflowForFunction.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNGetWorkflowForFunction(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNWorkflow)]:
result = _BNGetWorkflowForFunction(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetWorkflowList
_BNGetWorkflowList = core.BNGetWorkflowList
_BNGetWorkflowList.restype = ctypes.POINTER(ctypes.POINTER(BNWorkflow))
_BNGetWorkflowList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNGetWorkflowList(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNWorkflow))]:
result = _BNGetWorkflowList(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNGetWorkflowName
_BNGetWorkflowName = core.BNGetWorkflowName
_BNGetWorkflowName.restype = ctypes.POINTER(ctypes.c_byte)
_BNGetWorkflowName.argtypes = [
ctypes.POINTER(BNWorkflow),
]
# noinspection PyPep8Naming
def BNGetWorkflowName(
workflow: ctypes.POINTER(BNWorkflow)
) -> Optional[Optional[str]]:
result = _BNGetWorkflowName(workflow)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNGetWriterPosition
_BNGetWriterPosition = core.BNGetWriterPosition
_BNGetWriterPosition.restype = ctypes.c_ulonglong
_BNGetWriterPosition.argtypes = [
ctypes.POINTER(BNBinaryWriter),
]
# noinspection PyPep8Naming
def BNGetWriterPosition(
stream: ctypes.POINTER(BNBinaryWriter)
) -> int:
return _BNGetWriterPosition(stream)
# -------------------------------------------------------
# _BNHasDataVariables
_BNHasDataVariables = core.BNHasDataVariables
_BNHasDataVariables.restype = ctypes.c_bool
_BNHasDataVariables.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNHasDataVariables(
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNHasDataVariables(view)
# -------------------------------------------------------
# _BNHasFunctions
_BNHasFunctions = core.BNHasFunctions
_BNHasFunctions.restype = ctypes.c_bool
_BNHasFunctions.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNHasFunctions(
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNHasFunctions(view)
# -------------------------------------------------------
# _BNHasInitialAnalysis
_BNHasInitialAnalysis = core.BNHasInitialAnalysis
_BNHasInitialAnalysis.restype = ctypes.c_bool
_BNHasInitialAnalysis.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNHasInitialAnalysis(
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNHasInitialAnalysis(view)
# -------------------------------------------------------
# _BNHasSymbols
_BNHasSymbols = core.BNHasSymbols
_BNHasSymbols.restype = ctypes.c_bool
_BNHasSymbols.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNHasSymbols(
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNHasSymbols(view)
# -------------------------------------------------------
# _BNHasUnresolvedIndirectBranches
_BNHasUnresolvedIndirectBranches = core.BNHasUnresolvedIndirectBranches
_BNHasUnresolvedIndirectBranches.restype = ctypes.c_bool
_BNHasUnresolvedIndirectBranches.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNHasUnresolvedIndirectBranches(
func: ctypes.POINTER(BNFunction)
) -> bool:
return _BNHasUnresolvedIndirectBranches(func)
# -------------------------------------------------------
# _BNHighLevelILAddExpr
_BNHighLevelILAddExpr = core.BNHighLevelILAddExpr
_BNHighLevelILAddExpr.restype = ctypes.c_ulonglong
_BNHighLevelILAddExpr.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
HighLevelILOperationEnum,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNHighLevelILAddExpr(
func: ctypes.POINTER(BNHighLevelILFunction),
operation: HighLevelILOperation,
size: int,
a: int,
b: int,
c: int,
d: int,
e: int
) -> int:
return _BNHighLevelILAddExpr(func, operation, size, a, b, c, d, e)
# -------------------------------------------------------
# _BNHighLevelILAddExprWithLocation
_BNHighLevelILAddExprWithLocation = core.BNHighLevelILAddExprWithLocation
_BNHighLevelILAddExprWithLocation.restype = ctypes.c_ulonglong
_BNHighLevelILAddExprWithLocation.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
HighLevelILOperationEnum,
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNHighLevelILAddExprWithLocation(
func: ctypes.POINTER(BNHighLevelILFunction),
operation: HighLevelILOperation,
addr: int,
sourceOperand: int,
size: int,
a: int,
b: int,
c: int,
d: int,
e: int
) -> int:
return _BNHighLevelILAddExprWithLocation(func, operation, addr, sourceOperand, size, a, b, c, d, e)
# -------------------------------------------------------
# _BNHighLevelILAddOperandList
_BNHighLevelILAddOperandList = core.BNHighLevelILAddOperandList
_BNHighLevelILAddOperandList.restype = ctypes.c_ulonglong
_BNHighLevelILAddOperandList.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNHighLevelILAddOperandList(
func: ctypes.POINTER(BNHighLevelILFunction),
operands: ctypes.POINTER(ctypes.c_ulonglong),
count: int
) -> int:
return _BNHighLevelILAddOperandList(func, operands, count)
# -------------------------------------------------------
# _BNHighLevelILExprEqual
_BNHighLevelILExprEqual = core.BNHighLevelILExprEqual
_BNHighLevelILExprEqual.restype = ctypes.c_bool
_BNHighLevelILExprEqual.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNHighLevelILExprEqual(
leftFunc: ctypes.POINTER(BNHighLevelILFunction),
leftExpr: int,
rightFunc: ctypes.POINTER(BNHighLevelILFunction),
rightExpr: int
) -> bool:
return _BNHighLevelILExprEqual(leftFunc, leftExpr, rightFunc, rightExpr)
# -------------------------------------------------------
# _BNHighLevelILExprLessThan
_BNHighLevelILExprLessThan = core.BNHighLevelILExprLessThan
_BNHighLevelILExprLessThan.restype = ctypes.c_bool
_BNHighLevelILExprLessThan.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNHighLevelILExprLessThan(
leftFunc: ctypes.POINTER(BNHighLevelILFunction),
leftExpr: int,
rightFunc: ctypes.POINTER(BNHighLevelILFunction),
rightExpr: int
) -> bool:
return _BNHighLevelILExprLessThan(leftFunc, leftExpr, rightFunc, rightExpr)
# -------------------------------------------------------
# _BNHighLevelILFreeOperandList
_BNHighLevelILFreeOperandList = core.BNHighLevelILFreeOperandList
_BNHighLevelILFreeOperandList.restype = None
_BNHighLevelILFreeOperandList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNHighLevelILFreeOperandList(
operands: ctypes.POINTER(ctypes.c_ulonglong)
) -> None:
return _BNHighLevelILFreeOperandList(operands)
# -------------------------------------------------------
# _BNHighLevelILGetCurrentAddress
_BNHighLevelILGetCurrentAddress = core.BNHighLevelILGetCurrentAddress
_BNHighLevelILGetCurrentAddress.restype = ctypes.c_ulonglong
_BNHighLevelILGetCurrentAddress.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNHighLevelILGetCurrentAddress(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> int:
return _BNHighLevelILGetCurrentAddress(func)
# -------------------------------------------------------
# _BNHighLevelILGetOperandList
_BNHighLevelILGetOperandList = core.BNHighLevelILGetOperandList
_BNHighLevelILGetOperandList.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNHighLevelILGetOperandList.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNHighLevelILGetOperandList(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int,
operand: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNHighLevelILGetOperandList(func, expr, operand, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNHighLevelILSetCurrentAddress
_BNHighLevelILSetCurrentAddress = core.BNHighLevelILSetCurrentAddress
_BNHighLevelILSetCurrentAddress.restype = None
_BNHighLevelILSetCurrentAddress.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNHighLevelILSetCurrentAddress(
func: ctypes.POINTER(BNHighLevelILFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> None:
return _BNHighLevelILSetCurrentAddress(func, arch, addr)
# -------------------------------------------------------
# _BNImportedFunctionFromImportAddressSymbol
_BNImportedFunctionFromImportAddressSymbol = core.BNImportedFunctionFromImportAddressSymbol
_BNImportedFunctionFromImportAddressSymbol.restype = ctypes.POINTER(BNSymbol)
_BNImportedFunctionFromImportAddressSymbol.argtypes = [
ctypes.POINTER(BNSymbol),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNImportedFunctionFromImportAddressSymbol(
sym: ctypes.POINTER(BNSymbol),
addr: int
) -> Optional[ctypes.POINTER(BNSymbol)]:
result = _BNImportedFunctionFromImportAddressSymbol(sym, addr)
if not result:
return None
return result
# -------------------------------------------------------
# _BNInitCorePlugins
_BNInitCorePlugins = core.BNInitCorePlugins
_BNInitCorePlugins.restype = ctypes.c_bool
_BNInitCorePlugins.argtypes = [
]
# noinspection PyPep8Naming
def BNInitCorePlugins(
) -> bool:
return _BNInitCorePlugins()
# -------------------------------------------------------
# _BNInitDownloadInstance
_BNInitDownloadInstance = core.BNInitDownloadInstance
_BNInitDownloadInstance.restype = ctypes.POINTER(BNDownloadInstance)
_BNInitDownloadInstance.argtypes = [
ctypes.POINTER(BNDownloadProvider),
ctypes.POINTER(BNDownloadInstanceCallbacks),
]
# noinspection PyPep8Naming
def BNInitDownloadInstance(
provider: ctypes.POINTER(BNDownloadProvider),
callbacks: ctypes.POINTER(BNDownloadInstanceCallbacks)
) -> Optional[ctypes.POINTER(BNDownloadInstance)]:
result = _BNInitDownloadInstance(provider, callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNInitPlugins
_BNInitPlugins = core.BNInitPlugins
_BNInitPlugins.restype = ctypes.c_bool
_BNInitPlugins.argtypes = [
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNInitPlugins(
allowUserPlugins: bool
) -> bool:
return _BNInitPlugins(allowUserPlugins)
# -------------------------------------------------------
# _BNInitRepoPlugins
_BNInitRepoPlugins = core.BNInitRepoPlugins
_BNInitRepoPlugins.restype = None
_BNInitRepoPlugins.argtypes = [
]
# noinspection PyPep8Naming
def BNInitRepoPlugins(
) -> None:
return _BNInitRepoPlugins()
# -------------------------------------------------------
# _BNInitScriptingInstance
_BNInitScriptingInstance = core.BNInitScriptingInstance
_BNInitScriptingInstance.restype = ctypes.POINTER(BNScriptingInstance)
_BNInitScriptingInstance.argtypes = [
ctypes.POINTER(BNScriptingProvider),
ctypes.POINTER(BNScriptingInstanceCallbacks),
]
# noinspection PyPep8Naming
def BNInitScriptingInstance(
provider: ctypes.POINTER(BNScriptingProvider),
callbacks: ctypes.POINTER(BNScriptingInstanceCallbacks)
) -> Optional[ctypes.POINTER(BNScriptingInstance)]:
result = _BNInitScriptingInstance(provider, callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNInitUserPlugins
_BNInitUserPlugins = core.BNInitUserPlugins
_BNInitUserPlugins.restype = None
_BNInitUserPlugins.argtypes = [
]
# noinspection PyPep8Naming
def BNInitUserPlugins(
) -> None:
return _BNInitUserPlugins()
# -------------------------------------------------------
# _BNInitWebsocketClient
_BNInitWebsocketClient = core.BNInitWebsocketClient
_BNInitWebsocketClient.restype = ctypes.POINTER(BNWebsocketClient)
_BNInitWebsocketClient.argtypes = [
ctypes.POINTER(BNWebsocketProvider),
ctypes.POINTER(BNWebsocketClientCallbacks),
]
# noinspection PyPep8Naming
def BNInitWebsocketClient(
provider: ctypes.POINTER(BNWebsocketProvider),
callbacks: ctypes.POINTER(BNWebsocketClientCallbacks)
) -> Optional[ctypes.POINTER(BNWebsocketClient)]:
result = _BNInitWebsocketClient(provider, callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNInsertViewBuffer
_BNInsertViewBuffer = core.BNInsertViewBuffer
_BNInsertViewBuffer.restype = ctypes.c_ulonglong
_BNInsertViewBuffer.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNInsertViewBuffer(
view: ctypes.POINTER(BNBinaryView),
offset: int,
data: ctypes.POINTER(BNDataBuffer)
) -> int:
return _BNInsertViewBuffer(view, offset, data)
# -------------------------------------------------------
# _BNInsertViewData
_BNInsertViewData = core.BNInsertViewData
_BNInsertViewData.restype = ctypes.c_ulonglong
_BNInsertViewData.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_void_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNInsertViewData(
view: ctypes.POINTER(BNBinaryView),
offset: int,
data: Optional[ctypes.c_void_p],
len: int
) -> int:
return _BNInsertViewData(view, offset, data, len)
# -------------------------------------------------------
# _BNInstallPendingUpdate
_BNInstallPendingUpdate = core.BNInstallPendingUpdate
_BNInstallPendingUpdate.restype = None
_BNInstallPendingUpdate.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNInstallPendingUpdate(
errors: ctypes.POINTER(ctypes.c_char_p)
) -> None:
return _BNInstallPendingUpdate(errors)
# -------------------------------------------------------
# _BNInstallScriptingProviderModules
_BNInstallScriptingProviderModules = core.BNInstallScriptingProviderModules
_BNInstallScriptingProviderModules.restype = ctypes.c_bool
_BNInstallScriptingProviderModules.argtypes = [
ctypes.POINTER(BNScriptingProvider),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNInstallScriptingProviderModules(
provider: ctypes.POINTER(BNScriptingProvider),
modules: Optional[str]
) -> bool:
return _BNInstallScriptingProviderModules(provider, cstr(modules))
# -------------------------------------------------------
# _BNInvertBranch
_BNInvertBranch = core.BNInvertBranch
_BNInvertBranch.restype = ctypes.c_bool
_BNInvertBranch.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNInvertBranch(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> bool:
return _BNInvertBranch(view, arch, addr)
# -------------------------------------------------------
# _BNIsAlwaysBranchPatchAvailable
_BNIsAlwaysBranchPatchAvailable = core.BNIsAlwaysBranchPatchAvailable
_BNIsAlwaysBranchPatchAvailable.restype = ctypes.c_bool
_BNIsAlwaysBranchPatchAvailable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsAlwaysBranchPatchAvailable(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> bool:
return _BNIsAlwaysBranchPatchAvailable(view, arch, addr)
# -------------------------------------------------------
# _BNIsAnalysisChanged
_BNIsAnalysisChanged = core.BNIsAnalysisChanged
_BNIsAnalysisChanged.restype = ctypes.c_bool
_BNIsAnalysisChanged.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNIsAnalysisChanged(
file: ctypes.POINTER(BNFileMetadata)
) -> bool:
return _BNIsAnalysisChanged(file)
# -------------------------------------------------------
# _BNIsAnalysisTypeAutoDefined
_BNIsAnalysisTypeAutoDefined = core.BNIsAnalysisTypeAutoDefined
_BNIsAnalysisTypeAutoDefined.restype = ctypes.c_bool
_BNIsAnalysisTypeAutoDefined.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNIsAnalysisTypeAutoDefined(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName)
) -> bool:
return _BNIsAnalysisTypeAutoDefined(view, name)
# -------------------------------------------------------
# _BNIsApplyingDebugInfo
_BNIsApplyingDebugInfo = core.BNIsApplyingDebugInfo
_BNIsApplyingDebugInfo.restype = ctypes.c_bool
_BNIsApplyingDebugInfo.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNIsApplyingDebugInfo(
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNIsApplyingDebugInfo(view)
# -------------------------------------------------------
# _BNIsArchitectureAlwaysBranchPatchAvailable
_BNIsArchitectureAlwaysBranchPatchAvailable = core.BNIsArchitectureAlwaysBranchPatchAvailable
_BNIsArchitectureAlwaysBranchPatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureAlwaysBranchPatchAvailable.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsArchitectureAlwaysBranchPatchAvailable(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: int
) -> bool:
return _BNIsArchitectureAlwaysBranchPatchAvailable(arch, data, addr, len)
# -------------------------------------------------------
# _BNIsArchitectureGlobalRegister
_BNIsArchitectureGlobalRegister = core.BNIsArchitectureGlobalRegister
_BNIsArchitectureGlobalRegister.restype = ctypes.c_bool
_BNIsArchitectureGlobalRegister.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNIsArchitectureGlobalRegister(
arch: ctypes.POINTER(BNArchitecture),
reg: int
) -> bool:
return _BNIsArchitectureGlobalRegister(arch, reg)
# -------------------------------------------------------
# _BNIsArchitectureInvertBranchPatchAvailable
_BNIsArchitectureInvertBranchPatchAvailable = core.BNIsArchitectureInvertBranchPatchAvailable
_BNIsArchitectureInvertBranchPatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureInvertBranchPatchAvailable.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsArchitectureInvertBranchPatchAvailable(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: int
) -> bool:
return _BNIsArchitectureInvertBranchPatchAvailable(arch, data, addr, len)
# -------------------------------------------------------
# _BNIsArchitectureNeverBranchPatchAvailable
_BNIsArchitectureNeverBranchPatchAvailable = core.BNIsArchitectureNeverBranchPatchAvailable
_BNIsArchitectureNeverBranchPatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureNeverBranchPatchAvailable.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsArchitectureNeverBranchPatchAvailable(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: int
) -> bool:
return _BNIsArchitectureNeverBranchPatchAvailable(arch, data, addr, len)
# -------------------------------------------------------
# _BNIsArchitectureSkipAndReturnValuePatchAvailable
_BNIsArchitectureSkipAndReturnValuePatchAvailable = core.BNIsArchitectureSkipAndReturnValuePatchAvailable
_BNIsArchitectureSkipAndReturnValuePatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureSkipAndReturnValuePatchAvailable.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsArchitectureSkipAndReturnValuePatchAvailable(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: int
) -> bool:
return _BNIsArchitectureSkipAndReturnValuePatchAvailable(arch, data, addr, len)
# -------------------------------------------------------
# _BNIsArchitectureSkipAndReturnZeroPatchAvailable
_BNIsArchitectureSkipAndReturnZeroPatchAvailable = core.BNIsArchitectureSkipAndReturnZeroPatchAvailable
_BNIsArchitectureSkipAndReturnZeroPatchAvailable.restype = ctypes.c_bool
_BNIsArchitectureSkipAndReturnZeroPatchAvailable.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsArchitectureSkipAndReturnZeroPatchAvailable(
arch: ctypes.POINTER(BNArchitecture),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
len: int
) -> bool:
return _BNIsArchitectureSkipAndReturnZeroPatchAvailable(arch, data, addr, len)
# -------------------------------------------------------
# _BNIsArchitectureSystemRegister
_BNIsArchitectureSystemRegister = core.BNIsArchitectureSystemRegister
_BNIsArchitectureSystemRegister.restype = ctypes.c_bool
_BNIsArchitectureSystemRegister.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNIsArchitectureSystemRegister(
arch: ctypes.POINTER(BNArchitecture),
reg: int
) -> bool:
return _BNIsArchitectureSystemRegister(arch, reg)
# -------------------------------------------------------
# _BNIsBackedByDatabase
_BNIsBackedByDatabase = core.BNIsBackedByDatabase
_BNIsBackedByDatabase.restype = ctypes.c_bool
_BNIsBackedByDatabase.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNIsBackedByDatabase(
file: ctypes.POINTER(BNFileMetadata),
binaryViewType: Optional[str]
) -> bool:
return _BNIsBackedByDatabase(file, cstr(binaryViewType))
# -------------------------------------------------------
# _BNIsBackgroundTaskCancelled
_BNIsBackgroundTaskCancelled = core.BNIsBackgroundTaskCancelled
_BNIsBackgroundTaskCancelled.restype = ctypes.c_bool
_BNIsBackgroundTaskCancelled.argtypes = [
ctypes.POINTER(BNBackgroundTask),
]
# noinspection PyPep8Naming
def BNIsBackgroundTaskCancelled(
task: ctypes.POINTER(BNBackgroundTask)
) -> bool:
return _BNIsBackgroundTaskCancelled(task)
# -------------------------------------------------------
# _BNIsBackgroundTaskFinished
_BNIsBackgroundTaskFinished = core.BNIsBackgroundTaskFinished
_BNIsBackgroundTaskFinished.restype = ctypes.c_bool
_BNIsBackgroundTaskFinished.argtypes = [
ctypes.POINTER(BNBackgroundTask),
]
# noinspection PyPep8Naming
def BNIsBackgroundTaskFinished(
task: ctypes.POINTER(BNBackgroundTask)
) -> bool:
return _BNIsBackgroundTaskFinished(task)
# -------------------------------------------------------
# _BNIsBinaryViewTypeDeprecated
_BNIsBinaryViewTypeDeprecated = core.BNIsBinaryViewTypeDeprecated
_BNIsBinaryViewTypeDeprecated.restype = ctypes.c_bool
_BNIsBinaryViewTypeDeprecated.argtypes = [
ctypes.POINTER(BNBinaryViewType),
]
# noinspection PyPep8Naming
def BNIsBinaryViewTypeDeprecated(
type: ctypes.POINTER(BNBinaryViewType)
) -> bool:
return _BNIsBinaryViewTypeDeprecated(type)
# -------------------------------------------------------
# _BNIsBinaryViewTypeValidForData
_BNIsBinaryViewTypeValidForData = core.BNIsBinaryViewTypeValidForData
_BNIsBinaryViewTypeValidForData.restype = ctypes.c_bool
_BNIsBinaryViewTypeValidForData.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNIsBinaryViewTypeValidForData(
type: ctypes.POINTER(BNBinaryViewType),
data: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNIsBinaryViewTypeValidForData(type, data)
# -------------------------------------------------------
# _BNIsCallInstruction
_BNIsCallInstruction = core.BNIsCallInstruction
_BNIsCallInstruction.restype = ctypes.c_bool
_BNIsCallInstruction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsCallInstruction(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> bool:
return _BNIsCallInstruction(func, arch, addr)
# -------------------------------------------------------
# _BNIsDatabase
_BNIsDatabase = core.BNIsDatabase
_BNIsDatabase.restype = ctypes.c_bool
_BNIsDatabase.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNIsDatabase(
filename: Optional[str]
) -> bool:
return _BNIsDatabase(cstr(filename))
# -------------------------------------------------------
# _BNIsDebugInfoParserValidForView
_BNIsDebugInfoParserValidForView = core.BNIsDebugInfoParserValidForView
_BNIsDebugInfoParserValidForView.restype = ctypes.c_bool
_BNIsDebugInfoParserValidForView.argtypes = [
ctypes.POINTER(BNDebugInfoParser),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNIsDebugInfoParserValidForView(
parser: ctypes.POINTER(BNDebugInfoParser),
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNIsDebugInfoParserValidForView(parser, view)
# -------------------------------------------------------
# _BNIsDisassemblySettingsOptionSet
_BNIsDisassemblySettingsOptionSet = core.BNIsDisassemblySettingsOptionSet
_BNIsDisassemblySettingsOptionSet.restype = ctypes.c_bool
_BNIsDisassemblySettingsOptionSet.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
DisassemblyOptionEnum,
]
# noinspection PyPep8Naming
def BNIsDisassemblySettingsOptionSet(
settings: ctypes.POINTER(BNDisassemblySettings),
option: DisassemblyOption
) -> bool:
return _BNIsDisassemblySettingsOptionSet(settings, option)
# -------------------------------------------------------
# _BNIsEligibleForHeuristics
_BNIsEligibleForHeuristics = core.BNIsEligibleForHeuristics
_BNIsEligibleForHeuristics.restype = ctypes.c_bool
_BNIsEligibleForHeuristics.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNIsEligibleForHeuristics(
cc: ctypes.POINTER(BNCallingConvention)
) -> bool:
return _BNIsEligibleForHeuristics(cc)
# -------------------------------------------------------
# _BNIsEndOfFile
_BNIsEndOfFile = core.BNIsEndOfFile
_BNIsEndOfFile.restype = ctypes.c_bool
_BNIsEndOfFile.argtypes = [
ctypes.POINTER(BNBinaryReader),
]
# noinspection PyPep8Naming
def BNIsEndOfFile(
stream: ctypes.POINTER(BNBinaryReader)
) -> bool:
return _BNIsEndOfFile(stream)
# -------------------------------------------------------
# _BNIsEnterpriseServerAuthenticated
_BNIsEnterpriseServerAuthenticated = core.BNIsEnterpriseServerAuthenticated
_BNIsEnterpriseServerAuthenticated.restype = ctypes.c_bool
_BNIsEnterpriseServerAuthenticated.argtypes = [
]
# noinspection PyPep8Naming
def BNIsEnterpriseServerAuthenticated(
) -> bool:
return _BNIsEnterpriseServerAuthenticated()
# -------------------------------------------------------
# _BNIsEnterpriseServerConnected
_BNIsEnterpriseServerConnected = core.BNIsEnterpriseServerConnected
_BNIsEnterpriseServerConnected.restype = ctypes.c_bool
_BNIsEnterpriseServerConnected.argtypes = [
]
# noinspection PyPep8Naming
def BNIsEnterpriseServerConnected(
) -> bool:
return _BNIsEnterpriseServerConnected()
# -------------------------------------------------------
# _BNIsEnterpriseServerFloatingLicense
_BNIsEnterpriseServerFloatingLicense = core.BNIsEnterpriseServerFloatingLicense
_BNIsEnterpriseServerFloatingLicense.restype = ctypes.c_bool
_BNIsEnterpriseServerFloatingLicense.argtypes = [
]
# noinspection PyPep8Naming
def BNIsEnterpriseServerFloatingLicense(
) -> bool:
return _BNIsEnterpriseServerFloatingLicense()
# -------------------------------------------------------
# _BNIsEnterpriseServerInitialized
_BNIsEnterpriseServerInitialized = core.BNIsEnterpriseServerInitialized
_BNIsEnterpriseServerInitialized.restype = ctypes.c_bool
_BNIsEnterpriseServerInitialized.argtypes = [
]
# noinspection PyPep8Naming
def BNIsEnterpriseServerInitialized(
) -> bool:
return _BNIsEnterpriseServerInitialized()
# -------------------------------------------------------
# _BNIsEnterpriseServerLicenseStillActivated
_BNIsEnterpriseServerLicenseStillActivated = core.BNIsEnterpriseServerLicenseStillActivated
_BNIsEnterpriseServerLicenseStillActivated.restype = ctypes.c_bool
_BNIsEnterpriseServerLicenseStillActivated.argtypes = [
]
# noinspection PyPep8Naming
def BNIsEnterpriseServerLicenseStillActivated(
) -> bool:
return _BNIsEnterpriseServerLicenseStillActivated()
# -------------------------------------------------------
# _BNIsExecutableView
_BNIsExecutableView = core.BNIsExecutableView
_BNIsExecutableView.restype = ctypes.c_bool
_BNIsExecutableView.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNIsExecutableView(
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNIsExecutableView(view)
# -------------------------------------------------------
# _BNIsFileModified
_BNIsFileModified = core.BNIsFileModified
_BNIsFileModified.restype = ctypes.c_bool
_BNIsFileModified.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNIsFileModified(
file: ctypes.POINTER(BNFileMetadata)
) -> bool:
return _BNIsFileModified(file)
# -------------------------------------------------------
# _BNIsFlowGraphLayoutComplete
_BNIsFlowGraphLayoutComplete = core.BNIsFlowGraphLayoutComplete
_BNIsFlowGraphLayoutComplete.restype = ctypes.c_bool
_BNIsFlowGraphLayoutComplete.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNIsFlowGraphLayoutComplete(
graph: ctypes.POINTER(BNFlowGraph)
) -> bool:
return _BNIsFlowGraphLayoutComplete(graph)
# -------------------------------------------------------
# _BNIsFlowGraphLayoutRequestComplete
_BNIsFlowGraphLayoutRequestComplete = core.BNIsFlowGraphLayoutRequestComplete
_BNIsFlowGraphLayoutRequestComplete.restype = ctypes.c_bool
_BNIsFlowGraphLayoutRequestComplete.argtypes = [
ctypes.POINTER(BNFlowGraphLayoutRequest),
]
# noinspection PyPep8Naming
def BNIsFlowGraphLayoutRequestComplete(
layout: ctypes.POINTER(BNFlowGraphLayoutRequest)
) -> bool:
return _BNIsFlowGraphLayoutRequestComplete(layout)
# -------------------------------------------------------
# _BNIsFlowGraphOptionSet
_BNIsFlowGraphOptionSet = core.BNIsFlowGraphOptionSet
_BNIsFlowGraphOptionSet.restype = ctypes.c_bool
_BNIsFlowGraphOptionSet.argtypes = [
ctypes.POINTER(BNFlowGraph),
FlowGraphOptionEnum,
]
# noinspection PyPep8Naming
def BNIsFlowGraphOptionSet(
graph: ctypes.POINTER(BNFlowGraph),
option: FlowGraphOption
) -> bool:
return _BNIsFlowGraphOptionSet(graph, option)
# -------------------------------------------------------
# _BNIsFunctionAnalysisSkipped
_BNIsFunctionAnalysisSkipped = core.BNIsFunctionAnalysisSkipped
_BNIsFunctionAnalysisSkipped.restype = ctypes.c_bool
_BNIsFunctionAnalysisSkipped.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNIsFunctionAnalysisSkipped(
func: ctypes.POINTER(BNFunction)
) -> bool:
return _BNIsFunctionAnalysisSkipped(func)
# -------------------------------------------------------
# _BNIsFunctionInlinedDuringAnalysis
_BNIsFunctionInlinedDuringAnalysis = core.BNIsFunctionInlinedDuringAnalysis
_BNIsFunctionInlinedDuringAnalysis.restype = BNBoolWithConfidence
_BNIsFunctionInlinedDuringAnalysis.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNIsFunctionInlinedDuringAnalysis(
func: ctypes.POINTER(BNFunction)
) -> BNBoolWithConfidence:
return _BNIsFunctionInlinedDuringAnalysis(func)
# -------------------------------------------------------
# _BNIsFunctionPure
_BNIsFunctionPure = core.BNIsFunctionPure
_BNIsFunctionPure.restype = BNBoolWithConfidence
_BNIsFunctionPure.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNIsFunctionPure(
func: ctypes.POINTER(BNFunction)
) -> BNBoolWithConfidence:
return _BNIsFunctionPure(func)
# -------------------------------------------------------
# _BNIsFunctionTooLarge
_BNIsFunctionTooLarge = core.BNIsFunctionTooLarge
_BNIsFunctionTooLarge.restype = ctypes.c_bool
_BNIsFunctionTooLarge.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNIsFunctionTooLarge(
func: ctypes.POINTER(BNFunction)
) -> bool:
return _BNIsFunctionTooLarge(func)
# -------------------------------------------------------
# _BNIsFunctionUpdateNeeded
_BNIsFunctionUpdateNeeded = core.BNIsFunctionUpdateNeeded
_BNIsFunctionUpdateNeeded.restype = ctypes.c_bool
_BNIsFunctionUpdateNeeded.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNIsFunctionUpdateNeeded(
func: ctypes.POINTER(BNFunction)
) -> bool:
return _BNIsFunctionUpdateNeeded(func)
# -------------------------------------------------------
# _BNIsGNU3MangledString
_BNIsGNU3MangledString = core.BNIsGNU3MangledString
_BNIsGNU3MangledString.restype = ctypes.c_bool
_BNIsGNU3MangledString.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNIsGNU3MangledString(
mangledName: Optional[str]
) -> bool:
return _BNIsGNU3MangledString(cstr(mangledName))
# -------------------------------------------------------
# _BNIsHighLevelILBasicBlock
_BNIsHighLevelILBasicBlock = core.BNIsHighLevelILBasicBlock
_BNIsHighLevelILBasicBlock.restype = ctypes.c_bool
_BNIsHighLevelILBasicBlock.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNIsHighLevelILBasicBlock(
block: ctypes.POINTER(BNBasicBlock)
) -> bool:
return _BNIsHighLevelILBasicBlock(block)
# -------------------------------------------------------
# _BNIsHighLevelILFlowGraph
_BNIsHighLevelILFlowGraph = core.BNIsHighLevelILFlowGraph
_BNIsHighLevelILFlowGraph.restype = ctypes.c_bool
_BNIsHighLevelILFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNIsHighLevelILFlowGraph(
graph: ctypes.POINTER(BNFlowGraph)
) -> bool:
return _BNIsHighLevelILFlowGraph(graph)
# -------------------------------------------------------
# _BNIsHighLevelILSSAVarLive
_BNIsHighLevelILSSAVarLive = core.BNIsHighLevelILSSAVarLive
_BNIsHighLevelILSSAVarLive.restype = ctypes.c_bool
_BNIsHighLevelILSSAVarLive.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsHighLevelILSSAVarLive(
func: ctypes.POINTER(BNHighLevelILFunction),
var: ctypes.POINTER(BNVariable),
version: int
) -> bool:
return _BNIsHighLevelILSSAVarLive(func, var, version)
# -------------------------------------------------------
# _BNIsHighLevelILSSAVarLiveAt
_BNIsHighLevelILSSAVarLiveAt = core.BNIsHighLevelILSSAVarLiveAt
_BNIsHighLevelILSSAVarLiveAt.restype = ctypes.c_bool
_BNIsHighLevelILSSAVarLiveAt.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsHighLevelILSSAVarLiveAt(
func: ctypes.POINTER(BNHighLevelILFunction),
var: ctypes.POINTER(BNVariable),
version: int,
instr: int
) -> bool:
return _BNIsHighLevelILSSAVarLiveAt(func, var, version, instr)
# -------------------------------------------------------
# _BNIsHighLevelILVarLiveAt
_BNIsHighLevelILVarLiveAt = core.BNIsHighLevelILVarLiveAt
_BNIsHighLevelILVarLiveAt.restype = ctypes.c_bool
_BNIsHighLevelILVarLiveAt.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsHighLevelILVarLiveAt(
func: ctypes.POINTER(BNHighLevelILFunction),
var: ctypes.POINTER(BNVariable),
instr: int
) -> bool:
return _BNIsHighLevelILVarLiveAt(func, var, instr)
# -------------------------------------------------------
# _BNIsILBasicBlock
_BNIsILBasicBlock = core.BNIsILBasicBlock
_BNIsILBasicBlock.restype = ctypes.c_bool
_BNIsILBasicBlock.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNIsILBasicBlock(
block: ctypes.POINTER(BNBasicBlock)
) -> bool:
return _BNIsILBasicBlock(block)
# -------------------------------------------------------
# _BNIsILDisassemblyTextRenderer
_BNIsILDisassemblyTextRenderer = core.BNIsILDisassemblyTextRenderer
_BNIsILDisassemblyTextRenderer.restype = ctypes.c_bool
_BNIsILDisassemblyTextRenderer.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNIsILDisassemblyTextRenderer(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> bool:
return _BNIsILDisassemblyTextRenderer(renderer)
# -------------------------------------------------------
# _BNIsILFlowGraph
_BNIsILFlowGraph = core.BNIsILFlowGraph
_BNIsILFlowGraph.restype = ctypes.c_bool
_BNIsILFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNIsILFlowGraph(
graph: ctypes.POINTER(BNFlowGraph)
) -> bool:
return _BNIsILFlowGraph(graph)
# -------------------------------------------------------
# _BNIsIntegerToken
_BNIsIntegerToken = core.BNIsIntegerToken
_BNIsIntegerToken.restype = ctypes.c_bool
_BNIsIntegerToken.argtypes = [
InstructionTextTokenTypeEnum,
]
# noinspection PyPep8Naming
def BNIsIntegerToken(
type: InstructionTextTokenType
) -> bool:
return _BNIsIntegerToken(type)
# -------------------------------------------------------
# _BNIsInvertBranchPatchAvailable
_BNIsInvertBranchPatchAvailable = core.BNIsInvertBranchPatchAvailable
_BNIsInvertBranchPatchAvailable.restype = ctypes.c_bool
_BNIsInvertBranchPatchAvailable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsInvertBranchPatchAvailable(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> bool:
return _BNIsInvertBranchPatchAvailable(view, arch, addr)
# -------------------------------------------------------
# _BNIsKeyValueStoreEmpty
_BNIsKeyValueStoreEmpty = core.BNIsKeyValueStoreEmpty
_BNIsKeyValueStoreEmpty.restype = ctypes.c_bool
_BNIsKeyValueStoreEmpty.argtypes = [
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNIsKeyValueStoreEmpty(
store: ctypes.POINTER(BNKeyValueStore)
) -> bool:
return _BNIsKeyValueStoreEmpty(store)
# -------------------------------------------------------
# _BNIsLicenseValidated
_BNIsLicenseValidated = core.BNIsLicenseValidated
_BNIsLicenseValidated.restype = ctypes.c_bool
_BNIsLicenseValidated.argtypes = [
]
# noinspection PyPep8Naming
def BNIsLicenseValidated(
) -> bool:
return _BNIsLicenseValidated()
# -------------------------------------------------------
# _BNIsLinearViewCursorAfterEnd
_BNIsLinearViewCursorAfterEnd = core.BNIsLinearViewCursorAfterEnd
_BNIsLinearViewCursorAfterEnd.restype = ctypes.c_bool
_BNIsLinearViewCursorAfterEnd.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNIsLinearViewCursorAfterEnd(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> bool:
return _BNIsLinearViewCursorAfterEnd(cursor)
# -------------------------------------------------------
# _BNIsLinearViewCursorBeforeBegin
_BNIsLinearViewCursorBeforeBegin = core.BNIsLinearViewCursorBeforeBegin
_BNIsLinearViewCursorBeforeBegin.restype = ctypes.c_bool
_BNIsLinearViewCursorBeforeBegin.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNIsLinearViewCursorBeforeBegin(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> bool:
return _BNIsLinearViewCursorBeforeBegin(cursor)
# -------------------------------------------------------
# _BNIsLowLevelILBasicBlock
_BNIsLowLevelILBasicBlock = core.BNIsLowLevelILBasicBlock
_BNIsLowLevelILBasicBlock.restype = ctypes.c_bool
_BNIsLowLevelILBasicBlock.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNIsLowLevelILBasicBlock(
block: ctypes.POINTER(BNBasicBlock)
) -> bool:
return _BNIsLowLevelILBasicBlock(block)
# -------------------------------------------------------
# _BNIsLowLevelILFlowGraph
_BNIsLowLevelILFlowGraph = core.BNIsLowLevelILFlowGraph
_BNIsLowLevelILFlowGraph.restype = ctypes.c_bool
_BNIsLowLevelILFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNIsLowLevelILFlowGraph(
graph: ctypes.POINTER(BNFlowGraph)
) -> bool:
return _BNIsLowLevelILFlowGraph(graph)
# -------------------------------------------------------
# _BNIsMainThread
_BNIsMainThread = core.BNIsMainThread
_BNIsMainThread.restype = ctypes.c_bool
_BNIsMainThread.argtypes = [
]
# noinspection PyPep8Naming
def BNIsMainThread(
) -> bool:
return _BNIsMainThread()
# -------------------------------------------------------
# _BNIsMainThreadActionDone
_BNIsMainThreadActionDone = core.BNIsMainThreadActionDone
_BNIsMainThreadActionDone.restype = ctypes.c_bool
_BNIsMainThreadActionDone.argtypes = [
ctypes.POINTER(BNMainThreadAction),
]
# noinspection PyPep8Naming
def BNIsMainThreadActionDone(
action: ctypes.POINTER(BNMainThreadAction)
) -> bool:
return _BNIsMainThreadActionDone(action)
# -------------------------------------------------------
# _BNIsMediumLevelILBasicBlock
_BNIsMediumLevelILBasicBlock = core.BNIsMediumLevelILBasicBlock
_BNIsMediumLevelILBasicBlock.restype = ctypes.c_bool
_BNIsMediumLevelILBasicBlock.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNIsMediumLevelILBasicBlock(
block: ctypes.POINTER(BNBasicBlock)
) -> bool:
return _BNIsMediumLevelILBasicBlock(block)
# -------------------------------------------------------
# _BNIsMediumLevelILFlowGraph
_BNIsMediumLevelILFlowGraph = core.BNIsMediumLevelILFlowGraph
_BNIsMediumLevelILFlowGraph.restype = ctypes.c_bool
_BNIsMediumLevelILFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNIsMediumLevelILFlowGraph(
graph: ctypes.POINTER(BNFlowGraph)
) -> bool:
return _BNIsMediumLevelILFlowGraph(graph)
# -------------------------------------------------------
# _BNIsMediumLevelILSSAVarLive
_BNIsMediumLevelILSSAVarLive = core.BNIsMediumLevelILSSAVarLive
_BNIsMediumLevelILSSAVarLive.restype = ctypes.c_bool
_BNIsMediumLevelILSSAVarLive.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsMediumLevelILSSAVarLive(
func: ctypes.POINTER(BNMediumLevelILFunction),
var: ctypes.POINTER(BNVariable),
version: int
) -> bool:
return _BNIsMediumLevelILSSAVarLive(func, var, version)
# -------------------------------------------------------
# _BNIsNeverBranchPatchAvailable
_BNIsNeverBranchPatchAvailable = core.BNIsNeverBranchPatchAvailable
_BNIsNeverBranchPatchAvailable.restype = ctypes.c_bool
_BNIsNeverBranchPatchAvailable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsNeverBranchPatchAvailable(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> bool:
return _BNIsNeverBranchPatchAvailable(view, arch, addr)
# -------------------------------------------------------
# _BNIsNodeValidForFlowGraph
_BNIsNodeValidForFlowGraph = core.BNIsNodeValidForFlowGraph
_BNIsNodeValidForFlowGraph.restype = ctypes.c_bool
_BNIsNodeValidForFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNIsNodeValidForFlowGraph(
graph: ctypes.POINTER(BNFlowGraph),
node: ctypes.POINTER(BNFlowGraphNode)
) -> bool:
return _BNIsNodeValidForFlowGraph(graph, node)
# -------------------------------------------------------
# _BNIsOffsetBackedByFile
_BNIsOffsetBackedByFile = core.BNIsOffsetBackedByFile
_BNIsOffsetBackedByFile.restype = ctypes.c_bool
_BNIsOffsetBackedByFile.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsOffsetBackedByFile(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> bool:
return _BNIsOffsetBackedByFile(view, offset)
# -------------------------------------------------------
# _BNIsOffsetCodeSemantics
_BNIsOffsetCodeSemantics = core.BNIsOffsetCodeSemantics
_BNIsOffsetCodeSemantics.restype = ctypes.c_bool
_BNIsOffsetCodeSemantics.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsOffsetCodeSemantics(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> bool:
return _BNIsOffsetCodeSemantics(view, offset)
# -------------------------------------------------------
# _BNIsOffsetExecutable
_BNIsOffsetExecutable = core.BNIsOffsetExecutable
_BNIsOffsetExecutable.restype = ctypes.c_bool
_BNIsOffsetExecutable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsOffsetExecutable(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> bool:
return _BNIsOffsetExecutable(view, offset)
# -------------------------------------------------------
# _BNIsOffsetExternSemantics
_BNIsOffsetExternSemantics = core.BNIsOffsetExternSemantics
_BNIsOffsetExternSemantics.restype = ctypes.c_bool
_BNIsOffsetExternSemantics.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsOffsetExternSemantics(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> bool:
return _BNIsOffsetExternSemantics(view, offset)
# -------------------------------------------------------
# _BNIsOffsetReadable
_BNIsOffsetReadable = core.BNIsOffsetReadable
_BNIsOffsetReadable.restype = ctypes.c_bool
_BNIsOffsetReadable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsOffsetReadable(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> bool:
return _BNIsOffsetReadable(view, offset)
# -------------------------------------------------------
# _BNIsOffsetWritable
_BNIsOffsetWritable = core.BNIsOffsetWritable
_BNIsOffsetWritable.restype = ctypes.c_bool
_BNIsOffsetWritable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsOffsetWritable(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> bool:
return _BNIsOffsetWritable(view, offset)
# -------------------------------------------------------
# _BNIsOffsetWritableSemantics
_BNIsOffsetWritableSemantics = core.BNIsOffsetWritableSemantics
_BNIsOffsetWritableSemantics.restype = ctypes.c_bool
_BNIsOffsetWritableSemantics.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsOffsetWritableSemantics(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> bool:
return _BNIsOffsetWritableSemantics(view, offset)
# -------------------------------------------------------
# _BNIsPathDirectory
_BNIsPathDirectory = core.BNIsPathDirectory
_BNIsPathDirectory.restype = ctypes.c_bool
_BNIsPathDirectory.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNIsPathDirectory(
path: Optional[str]
) -> bool:
return _BNIsPathDirectory(cstr(path))
# -------------------------------------------------------
# _BNIsPathRegularFile
_BNIsPathRegularFile = core.BNIsPathRegularFile
_BNIsPathRegularFile.restype = ctypes.c_bool
_BNIsPathRegularFile.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNIsPathRegularFile(
path: Optional[str]
) -> bool:
return _BNIsPathRegularFile(cstr(path))
# -------------------------------------------------------
# _BNIsPluginsEnabled
_BNIsPluginsEnabled = core.BNIsPluginsEnabled
_BNIsPluginsEnabled.restype = ctypes.c_bool
_BNIsPluginsEnabled.argtypes = [
]
# noinspection PyPep8Naming
def BNIsPluginsEnabled(
) -> bool:
return _BNIsPluginsEnabled()
# -------------------------------------------------------
# _BNIsRelocatable
_BNIsRelocatable = core.BNIsRelocatable
_BNIsRelocatable.restype = ctypes.c_bool
_BNIsRelocatable.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNIsRelocatable(
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNIsRelocatable(view)
# -------------------------------------------------------
# _BNIsSaveSettingsOptionSet
_BNIsSaveSettingsOptionSet = core.BNIsSaveSettingsOptionSet
_BNIsSaveSettingsOptionSet.restype = ctypes.c_bool
_BNIsSaveSettingsOptionSet.argtypes = [
ctypes.POINTER(BNSaveSettings),
SaveOptionEnum,
]
# noinspection PyPep8Naming
def BNIsSaveSettingsOptionSet(
settings: ctypes.POINTER(BNSaveSettings),
option: SaveOption
) -> bool:
return _BNIsSaveSettingsOptionSet(settings, option)
# -------------------------------------------------------
# _BNIsShutdownRequested
_BNIsShutdownRequested = core.BNIsShutdownRequested
_BNIsShutdownRequested.restype = ctypes.c_bool
_BNIsShutdownRequested.argtypes = [
]
# noinspection PyPep8Naming
def BNIsShutdownRequested(
) -> bool:
return _BNIsShutdownRequested()
# -------------------------------------------------------
# _BNIsSkipAndReturnValuePatchAvailable
_BNIsSkipAndReturnValuePatchAvailable = core.BNIsSkipAndReturnValuePatchAvailable
_BNIsSkipAndReturnValuePatchAvailable.restype = ctypes.c_bool
_BNIsSkipAndReturnValuePatchAvailable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsSkipAndReturnValuePatchAvailable(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> bool:
return _BNIsSkipAndReturnValuePatchAvailable(view, arch, addr)
# -------------------------------------------------------
# _BNIsSkipAndReturnZeroPatchAvailable
_BNIsSkipAndReturnZeroPatchAvailable = core.BNIsSkipAndReturnZeroPatchAvailable
_BNIsSkipAndReturnZeroPatchAvailable.restype = ctypes.c_bool
_BNIsSkipAndReturnZeroPatchAvailable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsSkipAndReturnZeroPatchAvailable(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> bool:
return _BNIsSkipAndReturnZeroPatchAvailable(view, arch, addr)
# -------------------------------------------------------
# _BNIsSnapshotAutoSave
_BNIsSnapshotAutoSave = core.BNIsSnapshotAutoSave
_BNIsSnapshotAutoSave.restype = ctypes.c_bool
_BNIsSnapshotAutoSave.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNIsSnapshotAutoSave(
snapshot: ctypes.POINTER(BNSnapshot)
) -> bool:
return _BNIsSnapshotAutoSave(snapshot)
# -------------------------------------------------------
# _BNIsSnapshotDataAppliedWithoutError
_BNIsSnapshotDataAppliedWithoutError = core.BNIsSnapshotDataAppliedWithoutError
_BNIsSnapshotDataAppliedWithoutError.restype = ctypes.c_bool
_BNIsSnapshotDataAppliedWithoutError.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNIsSnapshotDataAppliedWithoutError(
view: ctypes.POINTER(BNFileMetadata)
) -> bool:
return _BNIsSnapshotDataAppliedWithoutError(view)
# -------------------------------------------------------
# _BNIsStackAdjustedOnReturn
_BNIsStackAdjustedOnReturn = core.BNIsStackAdjustedOnReturn
_BNIsStackAdjustedOnReturn.restype = ctypes.c_bool
_BNIsStackAdjustedOnReturn.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNIsStackAdjustedOnReturn(
cc: ctypes.POINTER(BNCallingConvention)
) -> bool:
return _BNIsStackAdjustedOnReturn(cc)
# -------------------------------------------------------
# _BNIsStackReservedForArgumentRegisters
_BNIsStackReservedForArgumentRegisters = core.BNIsStackReservedForArgumentRegisters
_BNIsStackReservedForArgumentRegisters.restype = ctypes.c_bool
_BNIsStackReservedForArgumentRegisters.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNIsStackReservedForArgumentRegisters(
cc: ctypes.POINTER(BNCallingConvention)
) -> bool:
return _BNIsStackReservedForArgumentRegisters(cc)
# -------------------------------------------------------
# _BNIsStructureBuilderPacked
_BNIsStructureBuilderPacked = core.BNIsStructureBuilderPacked
_BNIsStructureBuilderPacked.restype = ctypes.c_bool
_BNIsStructureBuilderPacked.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNIsStructureBuilderPacked(
s: ctypes.POINTER(BNStructureBuilder)
) -> bool:
return _BNIsStructureBuilderPacked(s)
# -------------------------------------------------------
# _BNIsStructureBuilderUnion
_BNIsStructureBuilderUnion = core.BNIsStructureBuilderUnion
_BNIsStructureBuilderUnion.restype = ctypes.c_bool
_BNIsStructureBuilderUnion.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNIsStructureBuilderUnion(
s: ctypes.POINTER(BNStructureBuilder)
) -> bool:
return _BNIsStructureBuilderUnion(s)
# -------------------------------------------------------
# _BNIsStructurePacked
_BNIsStructurePacked = core.BNIsStructurePacked
_BNIsStructurePacked.restype = ctypes.c_bool
_BNIsStructurePacked.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNIsStructurePacked(
s: ctypes.POINTER(BNStructure)
) -> bool:
return _BNIsStructurePacked(s)
# -------------------------------------------------------
# _BNIsStructureUnion
_BNIsStructureUnion = core.BNIsStructureUnion
_BNIsStructureUnion.restype = ctypes.c_bool
_BNIsStructureUnion.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNIsStructureUnion(
s: ctypes.POINTER(BNStructure)
) -> bool:
return _BNIsStructureUnion(s)
# -------------------------------------------------------
# _BNIsSymbolAutoDefined
_BNIsSymbolAutoDefined = core.BNIsSymbolAutoDefined
_BNIsSymbolAutoDefined.restype = ctypes.c_bool
_BNIsSymbolAutoDefined.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNIsSymbolAutoDefined(
sym: ctypes.POINTER(BNSymbol)
) -> bool:
return _BNIsSymbolAutoDefined(sym)
# -------------------------------------------------------
# _BNIsTypeArchive
_BNIsTypeArchive = core.BNIsTypeArchive
_BNIsTypeArchive.restype = ctypes.c_bool
_BNIsTypeArchive.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNIsTypeArchive(
path: Optional[str]
) -> bool:
return _BNIsTypeArchive(cstr(path))
# -------------------------------------------------------
# _BNIsTypeBuilderConst
_BNIsTypeBuilderConst = core.BNIsTypeBuilderConst
_BNIsTypeBuilderConst.restype = BNBoolWithConfidence
_BNIsTypeBuilderConst.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNIsTypeBuilderConst(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNBoolWithConfidence:
return _BNIsTypeBuilderConst(type)
# -------------------------------------------------------
# _BNIsTypeBuilderFloatingPoint
_BNIsTypeBuilderFloatingPoint = core.BNIsTypeBuilderFloatingPoint
_BNIsTypeBuilderFloatingPoint.restype = ctypes.c_bool
_BNIsTypeBuilderFloatingPoint.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNIsTypeBuilderFloatingPoint(
type: ctypes.POINTER(BNTypeBuilder)
) -> bool:
return _BNIsTypeBuilderFloatingPoint(type)
# -------------------------------------------------------
# _BNIsTypeBuilderPure
_BNIsTypeBuilderPure = core.BNIsTypeBuilderPure
_BNIsTypeBuilderPure.restype = BNBoolWithConfidence
_BNIsTypeBuilderPure.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNIsTypeBuilderPure(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNBoolWithConfidence:
return _BNIsTypeBuilderPure(type)
# -------------------------------------------------------
# _BNIsTypeBuilderSigned
_BNIsTypeBuilderSigned = core.BNIsTypeBuilderSigned
_BNIsTypeBuilderSigned.restype = BNBoolWithConfidence
_BNIsTypeBuilderSigned.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNIsTypeBuilderSigned(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNBoolWithConfidence:
return _BNIsTypeBuilderSigned(type)
# -------------------------------------------------------
# _BNIsTypeBuilderVolatile
_BNIsTypeBuilderVolatile = core.BNIsTypeBuilderVolatile
_BNIsTypeBuilderVolatile.restype = BNBoolWithConfidence
_BNIsTypeBuilderVolatile.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNIsTypeBuilderVolatile(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNBoolWithConfidence:
return _BNIsTypeBuilderVolatile(type)
# -------------------------------------------------------
# _BNIsTypeConst
_BNIsTypeConst = core.BNIsTypeConst
_BNIsTypeConst.restype = BNBoolWithConfidence
_BNIsTypeConst.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNIsTypeConst(
type: ctypes.POINTER(BNType)
) -> BNBoolWithConfidence:
return _BNIsTypeConst(type)
# -------------------------------------------------------
# _BNIsTypeFloatingPoint
_BNIsTypeFloatingPoint = core.BNIsTypeFloatingPoint
_BNIsTypeFloatingPoint.restype = ctypes.c_bool
_BNIsTypeFloatingPoint.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNIsTypeFloatingPoint(
type: ctypes.POINTER(BNType)
) -> bool:
return _BNIsTypeFloatingPoint(type)
# -------------------------------------------------------
# _BNIsTypePure
_BNIsTypePure = core.BNIsTypePure
_BNIsTypePure.restype = BNBoolWithConfidence
_BNIsTypePure.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNIsTypePure(
type: ctypes.POINTER(BNType)
) -> BNBoolWithConfidence:
return _BNIsTypePure(type)
# -------------------------------------------------------
# _BNIsTypeSigned
_BNIsTypeSigned = core.BNIsTypeSigned
_BNIsTypeSigned.restype = BNBoolWithConfidence
_BNIsTypeSigned.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNIsTypeSigned(
type: ctypes.POINTER(BNType)
) -> BNBoolWithConfidence:
return _BNIsTypeSigned(type)
# -------------------------------------------------------
# _BNIsTypeVolatile
_BNIsTypeVolatile = core.BNIsTypeVolatile
_BNIsTypeVolatile.restype = BNBoolWithConfidence
_BNIsTypeVolatile.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNIsTypeVolatile(
type: ctypes.POINTER(BNType)
) -> BNBoolWithConfidence:
return _BNIsTypeVolatile(type)
# -------------------------------------------------------
# _BNIsUIEnabled
_BNIsUIEnabled = core.BNIsUIEnabled
_BNIsUIEnabled.restype = ctypes.c_bool
_BNIsUIEnabled.argtypes = [
]
# noinspection PyPep8Naming
def BNIsUIEnabled(
) -> bool:
return _BNIsUIEnabled()
# -------------------------------------------------------
# _BNIsUpdateInstallationPending
_BNIsUpdateInstallationPending = core.BNIsUpdateInstallationPending
_BNIsUpdateInstallationPending.restype = ctypes.c_bool
_BNIsUpdateInstallationPending.argtypes = [
]
# noinspection PyPep8Naming
def BNIsUpdateInstallationPending(
) -> bool:
return _BNIsUpdateInstallationPending()
# -------------------------------------------------------
# _BNIsValidForData
_BNIsValidForData = core.BNIsValidForData
_BNIsValidForData.restype = ctypes.c_bool
_BNIsValidForData.argtypes = [
ctypes.c_void_p,
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNType),
ctypes.POINTER(BNTypeContext),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsValidForData(
ctxt: Optional[ctypes.c_void_p],
view: ctypes.POINTER(BNBinaryView),
addr: int,
type: ctypes.POINTER(BNType),
typeCtx: ctypes.POINTER(BNTypeContext),
ctxCount: int
) -> bool:
return _BNIsValidForData(ctxt, view, addr, type, typeCtx, ctxCount)
# -------------------------------------------------------
# _BNIsValidOffset
_BNIsValidOffset = core.BNIsValidOffset
_BNIsValidOffset.restype = ctypes.c_bool
_BNIsValidOffset.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNIsValidOffset(
view: ctypes.POINTER(BNBinaryView),
offset: int
) -> bool:
return _BNIsValidOffset(view, offset)
# -------------------------------------------------------
# _BNIsVariableUserDefined
_BNIsVariableUserDefined = core.BNIsVariableUserDefined
_BNIsVariableUserDefined.restype = ctypes.c_bool
_BNIsVariableUserDefined.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNIsVariableUserDefined(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable)
) -> bool:
return _BNIsVariableUserDefined(func, var)
# -------------------------------------------------------
# _BNIsViewModified
_BNIsViewModified = core.BNIsViewModified
_BNIsViewModified.restype = ctypes.c_bool
_BNIsViewModified.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNIsViewModified(
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNIsViewModified(view)
# -------------------------------------------------------
# _BNKeyValueStoreHasValue
_BNKeyValueStoreHasValue = core.BNKeyValueStoreHasValue
_BNKeyValueStoreHasValue.restype = ctypes.c_bool
_BNKeyValueStoreHasValue.argtypes = [
ctypes.POINTER(BNKeyValueStore),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNKeyValueStoreHasValue(
store: ctypes.POINTER(BNKeyValueStore),
name: Optional[str]
) -> bool:
return _BNKeyValueStoreHasValue(store, cstr(name))
# -------------------------------------------------------
# _BNLinearViewCursorNext
_BNLinearViewCursorNext = core.BNLinearViewCursorNext
_BNLinearViewCursorNext.restype = ctypes.c_bool
_BNLinearViewCursorNext.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNLinearViewCursorNext(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> bool:
return _BNLinearViewCursorNext(cursor)
# -------------------------------------------------------
# _BNLinearViewCursorPrevious
_BNLinearViewCursorPrevious = core.BNLinearViewCursorPrevious
_BNLinearViewCursorPrevious.restype = ctypes.c_bool
_BNLinearViewCursorPrevious.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNLinearViewCursorPrevious(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> bool:
return _BNLinearViewCursorPrevious(cursor)
# -------------------------------------------------------
# _BNLlvmServicesAssemble
_BNLlvmServicesAssemble = core.BNLlvmServicesAssemble
_BNLlvmServicesAssemble.restype = ctypes.c_int
_BNLlvmServicesAssemble.argtypes = [
ctypes.c_char_p,
ctypes.c_int,
ctypes.c_char_p,
ctypes.c_int,
ctypes.c_int,
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_int),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_int),
]
# noinspection PyPep8Naming
def BNLlvmServicesAssemble(
src: Optional[str],
dialect: int,
triplet: Optional[str],
codeModel: int,
relocMode: int,
outBytes: ctypes.POINTER(ctypes.c_char_p),
outBytesLen: ctypes.POINTER(ctypes.c_int),
err: ctypes.POINTER(ctypes.c_char_p),
errLen: ctypes.POINTER(ctypes.c_int)
) -> int:
return _BNLlvmServicesAssemble(cstr(src), dialect, cstr(triplet), codeModel, relocMode, outBytes, outBytesLen, err, errLen)
# -------------------------------------------------------
# _BNLlvmServicesAssembleFree
_BNLlvmServicesAssembleFree = core.BNLlvmServicesAssembleFree
_BNLlvmServicesAssembleFree.restype = None
_BNLlvmServicesAssembleFree.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNLlvmServicesAssembleFree(
outBytes: Optional[str],
err: Optional[str]
) -> None:
return _BNLlvmServicesAssembleFree(cstr(outBytes), cstr(err))
# -------------------------------------------------------
# _BNLlvmServicesInit
_BNLlvmServicesInit = core.BNLlvmServicesInit
_BNLlvmServicesInit.restype = None
_BNLlvmServicesInit.argtypes = [
]
# noinspection PyPep8Naming
def BNLlvmServicesInit(
) -> None:
return _BNLlvmServicesInit()
# -------------------------------------------------------
# _BNLoadBinaryView
_BNLoadBinaryView = core.BNLoadBinaryView
_BNLoadBinaryView.restype = ctypes.POINTER(BNBinaryView)
_BNLoadBinaryView.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_bool,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.POINTER(BNMetadata),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNLoadBinaryView(
view: ctypes.POINTER(BNBinaryView),
updateAnalysis: bool,
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong),
options: ctypes.POINTER(BNMetadata),
isDatabase: bool
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNLoadBinaryView(view, updateAnalysis, progress, options, isDatabase)
if not result:
return None
return result
# -------------------------------------------------------
# _BNLoadFilename
_BNLoadFilename = core.BNLoadFilename
_BNLoadFilename.restype = ctypes.POINTER(BNBinaryView)
_BNLoadFilename.argtypes = [
ctypes.c_char_p,
ctypes.c_bool,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNLoadFilename(
filename: Optional[str],
updateAnalysis: bool,
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong),
options: ctypes.POINTER(BNMetadata)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNLoadFilename(cstr(filename), updateAnalysis, progress, options)
if not result:
return None
return result
# -------------------------------------------------------
# _BNLoadProjectFile
_BNLoadProjectFile = core.BNLoadProjectFile
_BNLoadProjectFile.restype = ctypes.POINTER(BNBinaryView)
_BNLoadProjectFile.argtypes = [
ctypes.POINTER(BNProjectFile),
ctypes.c_bool,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNLoadProjectFile(
projectFile: ctypes.POINTER(BNProjectFile),
updateAnalysis: bool,
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_ulonglong, ctypes.c_ulonglong),
options: ctypes.POINTER(BNMetadata)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNLoadProjectFile(projectFile, updateAnalysis, progress, options)
if not result:
return None
return result
# -------------------------------------------------------
# _BNLoadScriptingProviderModule
_BNLoadScriptingProviderModule = core.BNLoadScriptingProviderModule
_BNLoadScriptingProviderModule.restype = ctypes.c_bool
_BNLoadScriptingProviderModule.argtypes = [
ctypes.POINTER(BNScriptingProvider),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNLoadScriptingProviderModule(
provider: ctypes.POINTER(BNScriptingProvider),
repository: Optional[str],
module: Optional[str],
force: bool
) -> bool:
return _BNLoadScriptingProviderModule(provider, cstr(repository), cstr(module), force)
# -------------------------------------------------------
# _BNLoadSettingsFile
_BNLoadSettingsFile = core.BNLoadSettingsFile
_BNLoadSettingsFile.restype = ctypes.c_bool
_BNLoadSettingsFile.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
SettingsScopeEnum,
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNLoadSettingsFile(
settings: ctypes.POINTER(BNSettings),
fileName: Optional[str],
scope: SettingsScope,
view: ctypes.POINTER(BNBinaryView)
) -> bool:
return _BNLoadSettingsFile(settings, cstr(fileName), scope, view)
# -------------------------------------------------------
# _BNLoadTypeLibraryFromFile
_BNLoadTypeLibraryFromFile = core.BNLoadTypeLibraryFromFile
_BNLoadTypeLibraryFromFile.restype = ctypes.POINTER(BNTypeLibrary)
_BNLoadTypeLibraryFromFile.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNLoadTypeLibraryFromFile(
path: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
result = _BNLoadTypeLibraryFromFile(cstr(path))
if not result:
return None
return result
# -------------------------------------------------------
# _BNLog
_BNLog = core.BNLog
_BNLog.restype = None
def BNLog(level, *args):
return _BNLog(level, *[cstr(arg) for arg in args])
# -------------------------------------------------------
# _BNLogAlert
_BNLogAlert = core.BNLogAlert
_BNLogAlert.restype = None
def BNLogAlert(*args):
return _BNLogAlert(*[cstr(arg) for arg in args])
# -------------------------------------------------------
# _BNLogCreateLogger
_BNLogCreateLogger = core.BNLogCreateLogger
_BNLogCreateLogger.restype = ctypes.POINTER(BNLogger)
_BNLogCreateLogger.argtypes = [
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLogCreateLogger(
loggerName: Optional[str],
sessionId: int
) -> Optional[ctypes.POINTER(BNLogger)]:
result = _BNLogCreateLogger(cstr(loggerName), sessionId)
if not result:
return None
return result
# -------------------------------------------------------
# _BNLogDebug
_BNLogDebug = core.BNLogDebug
_BNLogDebug.restype = None
def BNLogDebug(*args):
return _BNLogDebug(*[cstr(arg) for arg in args])
# -------------------------------------------------------
# _BNLogError
_BNLogError = core.BNLogError
_BNLogError.restype = None
def BNLogError(*args):
return _BNLogError(*[cstr(arg) for arg in args])
# -------------------------------------------------------
# _BNLogGetLogger
_BNLogGetLogger = core.BNLogGetLogger
_BNLogGetLogger.restype = ctypes.POINTER(BNLogger)
_BNLogGetLogger.argtypes = [
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLogGetLogger(
loggerName: Optional[str],
sessionId: int
) -> Optional[ctypes.POINTER(BNLogger)]:
result = _BNLogGetLogger(cstr(loggerName), sessionId)
if not result:
return None
return result
# -------------------------------------------------------
# _BNLogGetLoggerNames
_BNLogGetLoggerNames = core.BNLogGetLoggerNames
_BNLogGetLoggerNames.restype = ctypes.POINTER(ctypes.c_char_p)
_BNLogGetLoggerNames.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNLogGetLoggerNames(
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNLogGetLoggerNames(count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNLogInfo
_BNLogInfo = core.BNLogInfo
_BNLogInfo.restype = None
def BNLogInfo(*args):
return _BNLogInfo(*[cstr(arg) for arg in args])
# -------------------------------------------------------
# _BNLogRegisterLoggerCallback
_BNLogRegisterLoggerCallback = core.BNLogRegisterLoggerCallback
_BNLogRegisterLoggerCallback.restype = None
_BNLogRegisterLoggerCallback.argtypes = [
ctypes.CFUNCTYPE(None, ctypes.c_char_p, ctypes.c_void_p),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNLogRegisterLoggerCallback(
cb: ctypes.CFUNCTYPE(None, ctypes.c_char_p, ctypes.c_void_p),
ctxt: Optional[ctypes.c_void_p]
) -> None:
return _BNLogRegisterLoggerCallback(cb, ctxt)
# -------------------------------------------------------
# _BNLogString
_BNLogString = core.BNLogString
_BNLogString.restype = None
_BNLogString.argtypes = [
ctypes.c_ulonglong,
LogLevelEnum,
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNLogString(
session: int,
level: LogLevel,
logger_name: Optional[str],
tid: int,
str: Optional[str]
) -> None:
return _BNLogString(session, level, cstr(logger_name), tid, cstr(str))
# -------------------------------------------------------
# _BNLogToFile
_BNLogToFile = core.BNLogToFile
_BNLogToFile.restype = ctypes.c_bool
_BNLogToFile.argtypes = [
LogLevelEnum,
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNLogToFile(
minimumLevel: LogLevel,
path: Optional[str],
append: bool
) -> bool:
return _BNLogToFile(minimumLevel, cstr(path), append)
# -------------------------------------------------------
# _BNLogToStderr
_BNLogToStderr = core.BNLogToStderr
_BNLogToStderr.restype = None
_BNLogToStderr.argtypes = [
LogLevelEnum,
]
# noinspection PyPep8Naming
def BNLogToStderr(
minimumLevel: LogLevel
) -> None:
return _BNLogToStderr(minimumLevel)
# -------------------------------------------------------
# _BNLogToStdout
_BNLogToStdout = core.BNLogToStdout
_BNLogToStdout.restype = None
_BNLogToStdout.argtypes = [
LogLevelEnum,
]
# noinspection PyPep8Naming
def BNLogToStdout(
minimumLevel: LogLevel
) -> None:
return _BNLogToStdout(minimumLevel)
# -------------------------------------------------------
# _BNLogWarn
_BNLogWarn = core.BNLogWarn
_BNLogWarn.restype = None
def BNLogWarn(*args):
return _BNLogWarn(*[cstr(arg) for arg in args])
# -------------------------------------------------------
# _BNLoggerGetName
_BNLoggerGetName = core.BNLoggerGetName
_BNLoggerGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNLoggerGetName.argtypes = [
ctypes.POINTER(BNLogger),
]
# noinspection PyPep8Naming
def BNLoggerGetName(
logger: ctypes.POINTER(BNLogger)
) -> Optional[Optional[str]]:
result = _BNLoggerGetName(logger)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNLoggerGetSessionId
_BNLoggerGetSessionId = core.BNLoggerGetSessionId
_BNLoggerGetSessionId.restype = ctypes.c_ulonglong
_BNLoggerGetSessionId.argtypes = [
ctypes.POINTER(BNLogger),
]
# noinspection PyPep8Naming
def BNLoggerGetSessionId(
logger: ctypes.POINTER(BNLogger)
) -> int:
return _BNLoggerGetSessionId(logger)
# -------------------------------------------------------
# _BNLoggerLog
_BNLoggerLog = core.BNLoggerLog
_BNLoggerLog.restype = None
def BNLoggerLog(*args):
return _BNLoggerLog(*[cstr(arg) for arg in args])
# -------------------------------------------------------
# _BNLoggerLogString
_BNLoggerLogString = core.BNLoggerLogString
_BNLoggerLogString.restype = None
_BNLoggerLogString.argtypes = [
ctypes.POINTER(BNLogger),
LogLevelEnum,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNLoggerLogString(
logger: ctypes.POINTER(BNLogger),
level: LogLevel,
msg: Optional[str]
) -> None:
return _BNLoggerLogString(logger, level, cstr(msg))
# -------------------------------------------------------
# _BNLookupImportedTypePlatform
_BNLookupImportedTypePlatform = core.BNLookupImportedTypePlatform
_BNLookupImportedTypePlatform.restype = ctypes.c_bool
_BNLookupImportedTypePlatform.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.POINTER(BNPlatform)),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNLookupImportedTypePlatform(
view: ctypes.POINTER(BNBinaryView),
typeName: ctypes.POINTER(BNQualifiedName),
platform: ctypes.POINTER(ctypes.POINTER(BNPlatform)),
resultName: ctypes.POINTER(BNQualifiedName)
) -> bool:
return _BNLookupImportedTypePlatform(view, typeName, platform, resultName)
# -------------------------------------------------------
# _BNLookupTypeArchiveById
_BNLookupTypeArchiveById = core.BNLookupTypeArchiveById
_BNLookupTypeArchiveById.restype = ctypes.POINTER(BNTypeArchive)
_BNLookupTypeArchiveById.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNLookupTypeArchiveById(
id: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeArchive)]:
result = _BNLookupTypeArchiveById(cstr(id))
if not result:
return None
return result
# -------------------------------------------------------
# _BNLookupTypeLibraryByGuid
_BNLookupTypeLibraryByGuid = core.BNLookupTypeLibraryByGuid
_BNLookupTypeLibraryByGuid.restype = ctypes.POINTER(BNTypeLibrary)
_BNLookupTypeLibraryByGuid.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNLookupTypeLibraryByGuid(
arch: ctypes.POINTER(BNArchitecture),
guid: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
result = _BNLookupTypeLibraryByGuid(arch, cstr(guid))
if not result:
return None
return result
# -------------------------------------------------------
# _BNLookupTypeLibraryByName
_BNLookupTypeLibraryByName = core.BNLookupTypeLibraryByName
_BNLookupTypeLibraryByName.restype = ctypes.POINTER(BNTypeLibrary)
_BNLookupTypeLibraryByName.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNLookupTypeLibraryByName(
arch: ctypes.POINTER(BNArchitecture),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
result = _BNLookupTypeLibraryByName(arch, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNLowLevelILAddExpr
_BNLowLevelILAddExpr = core.BNLowLevelILAddExpr
_BNLowLevelILAddExpr.restype = ctypes.c_ulonglong
_BNLowLevelILAddExpr.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
LowLevelILOperationEnum,
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLowLevelILAddExpr(
func: ctypes.POINTER(BNLowLevelILFunction),
operation: LowLevelILOperation,
size: int,
flags: int,
a: int,
b: int,
c: int,
d: int
) -> int:
return _BNLowLevelILAddExpr(func, operation, size, flags, a, b, c, d)
# -------------------------------------------------------
# _BNLowLevelILAddExprWithLocation
_BNLowLevelILAddExprWithLocation = core.BNLowLevelILAddExprWithLocation
_BNLowLevelILAddExprWithLocation.restype = ctypes.c_ulonglong
_BNLowLevelILAddExprWithLocation.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_uint,
LowLevelILOperationEnum,
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLowLevelILAddExprWithLocation(
func: ctypes.POINTER(BNLowLevelILFunction),
addr: int,
sourceOperand: int,
operation: LowLevelILOperation,
size: int,
flags: int,
a: int,
b: int,
c: int,
d: int
) -> int:
return _BNLowLevelILAddExprWithLocation(func, addr, sourceOperand, operation, size, flags, a, b, c, d)
# -------------------------------------------------------
# _BNLowLevelILAddInstruction
_BNLowLevelILAddInstruction = core.BNLowLevelILAddInstruction
_BNLowLevelILAddInstruction.restype = ctypes.c_ulonglong
_BNLowLevelILAddInstruction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLowLevelILAddInstruction(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int
) -> int:
return _BNLowLevelILAddInstruction(func, expr)
# -------------------------------------------------------
# _BNLowLevelILAddLabelMap
_BNLowLevelILAddLabelMap = core.BNLowLevelILAddLabelMap
_BNLowLevelILAddLabelMap.restype = ctypes.c_ulonglong
_BNLowLevelILAddLabelMap.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.POINTER(BNLowLevelILLabel)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLowLevelILAddLabelMap(
func: ctypes.POINTER(BNLowLevelILFunction),
values: ctypes.POINTER(ctypes.c_ulonglong),
labels: ctypes.POINTER(ctypes.POINTER(BNLowLevelILLabel)),
count: int
) -> int:
return _BNLowLevelILAddLabelMap(func, values, labels, count)
# -------------------------------------------------------
# _BNLowLevelILAddOperandList
_BNLowLevelILAddOperandList = core.BNLowLevelILAddOperandList
_BNLowLevelILAddOperandList.restype = ctypes.c_ulonglong
_BNLowLevelILAddOperandList.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLowLevelILAddOperandList(
func: ctypes.POINTER(BNLowLevelILFunction),
operands: ctypes.POINTER(ctypes.c_ulonglong),
count: int
) -> int:
return _BNLowLevelILAddOperandList(func, operands, count)
# -------------------------------------------------------
# _BNLowLevelILClearIndirectBranches
_BNLowLevelILClearIndirectBranches = core.BNLowLevelILClearIndirectBranches
_BNLowLevelILClearIndirectBranches.restype = None
_BNLowLevelILClearIndirectBranches.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNLowLevelILClearIndirectBranches(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> None:
return _BNLowLevelILClearIndirectBranches(func)
# -------------------------------------------------------
# _BNLowLevelILFreeOperandList
_BNLowLevelILFreeOperandList = core.BNLowLevelILFreeOperandList
_BNLowLevelILFreeOperandList.restype = None
_BNLowLevelILFreeOperandList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNLowLevelILFreeOperandList(
operands: ctypes.POINTER(ctypes.c_ulonglong)
) -> None:
return _BNLowLevelILFreeOperandList(operands)
# -------------------------------------------------------
# _BNLowLevelILGetCurrentAddress
_BNLowLevelILGetCurrentAddress = core.BNLowLevelILGetCurrentAddress
_BNLowLevelILGetCurrentAddress.restype = ctypes.c_ulonglong
_BNLowLevelILGetCurrentAddress.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNLowLevelILGetCurrentAddress(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> int:
return _BNLowLevelILGetCurrentAddress(func)
# -------------------------------------------------------
# _BNLowLevelILGetInstructionStart
_BNLowLevelILGetInstructionStart = core.BNLowLevelILGetInstructionStart
_BNLowLevelILGetInstructionStart.restype = ctypes.c_ulonglong
_BNLowLevelILGetInstructionStart.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLowLevelILGetInstructionStart(
func: ctypes.POINTER(BNLowLevelILFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> int:
return _BNLowLevelILGetInstructionStart(func, arch, addr)
# -------------------------------------------------------
# _BNLowLevelILGetOperandList
_BNLowLevelILGetOperandList = core.BNLowLevelILGetOperandList
_BNLowLevelILGetOperandList.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNLowLevelILGetOperandList.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNLowLevelILGetOperandList(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int,
operand: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNLowLevelILGetOperandList(func, expr, operand, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNLowLevelILGoto
_BNLowLevelILGoto = core.BNLowLevelILGoto
_BNLowLevelILGoto.restype = ctypes.c_ulonglong
_BNLowLevelILGoto.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNLowLevelILLabel),
]
# noinspection PyPep8Naming
def BNLowLevelILGoto(
func: ctypes.POINTER(BNLowLevelILFunction),
label: ctypes.POINTER(BNLowLevelILLabel)
) -> int:
return _BNLowLevelILGoto(func, label)
# -------------------------------------------------------
# _BNLowLevelILGotoWithLocation
_BNLowLevelILGotoWithLocation = core.BNLowLevelILGotoWithLocation
_BNLowLevelILGotoWithLocation.restype = ctypes.c_ulonglong
_BNLowLevelILGotoWithLocation.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNLowLevelILLabel),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNLowLevelILGotoWithLocation(
func: ctypes.POINTER(BNLowLevelILFunction),
label: ctypes.POINTER(BNLowLevelILLabel),
addr: int,
sourceOperand: int
) -> int:
return _BNLowLevelILGotoWithLocation(func, label, addr, sourceOperand)
# -------------------------------------------------------
# _BNLowLevelILIf
_BNLowLevelILIf = core.BNLowLevelILIf
_BNLowLevelILIf.restype = ctypes.c_ulonglong
_BNLowLevelILIf.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(BNLowLevelILLabel),
ctypes.POINTER(BNLowLevelILLabel),
]
# noinspection PyPep8Naming
def BNLowLevelILIf(
func: ctypes.POINTER(BNLowLevelILFunction),
op: int,
t: ctypes.POINTER(BNLowLevelILLabel),
f: ctypes.POINTER(BNLowLevelILLabel)
) -> int:
return _BNLowLevelILIf(func, op, t, f)
# -------------------------------------------------------
# _BNLowLevelILIfWithLocation
_BNLowLevelILIfWithLocation = core.BNLowLevelILIfWithLocation
_BNLowLevelILIfWithLocation.restype = ctypes.c_ulonglong
_BNLowLevelILIfWithLocation.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(BNLowLevelILLabel),
ctypes.POINTER(BNLowLevelILLabel),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNLowLevelILIfWithLocation(
func: ctypes.POINTER(BNLowLevelILFunction),
op: int,
t: ctypes.POINTER(BNLowLevelILLabel),
f: ctypes.POINTER(BNLowLevelILLabel),
addr: int,
sourceOperand: int
) -> int:
return _BNLowLevelILIfWithLocation(func, op, t, f, addr, sourceOperand)
# -------------------------------------------------------
# _BNLowLevelILInitLabel
_BNLowLevelILInitLabel = core.BNLowLevelILInitLabel
_BNLowLevelILInitLabel.restype = None
_BNLowLevelILInitLabel.argtypes = [
ctypes.POINTER(BNLowLevelILLabel),
]
# noinspection PyPep8Naming
def BNLowLevelILInitLabel(
label: ctypes.POINTER(BNLowLevelILLabel)
) -> None:
return _BNLowLevelILInitLabel(label)
# -------------------------------------------------------
# _BNLowLevelILMarkLabel
_BNLowLevelILMarkLabel = core.BNLowLevelILMarkLabel
_BNLowLevelILMarkLabel.restype = None
_BNLowLevelILMarkLabel.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNLowLevelILLabel),
]
# noinspection PyPep8Naming
def BNLowLevelILMarkLabel(
func: ctypes.POINTER(BNLowLevelILFunction),
label: ctypes.POINTER(BNLowLevelILLabel)
) -> None:
return _BNLowLevelILMarkLabel(func, label)
# -------------------------------------------------------
# _BNLowLevelILSetCurrentAddress
_BNLowLevelILSetCurrentAddress = core.BNLowLevelILSetCurrentAddress
_BNLowLevelILSetCurrentAddress.restype = None
_BNLowLevelILSetCurrentAddress.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLowLevelILSetCurrentAddress(
func: ctypes.POINTER(BNLowLevelILFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> None:
return _BNLowLevelILSetCurrentAddress(func, arch, addr)
# -------------------------------------------------------
# _BNLowLevelILSetCurrentSourceBlock
_BNLowLevelILSetCurrentSourceBlock = core.BNLowLevelILSetCurrentSourceBlock
_BNLowLevelILSetCurrentSourceBlock.restype = None
_BNLowLevelILSetCurrentSourceBlock.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNLowLevelILSetCurrentSourceBlock(
func: ctypes.POINTER(BNLowLevelILFunction),
source: ctypes.POINTER(BNBasicBlock)
) -> None:
return _BNLowLevelILSetCurrentSourceBlock(func, source)
# -------------------------------------------------------
# _BNLowLevelILSetExprSourceOperand
_BNLowLevelILSetExprSourceOperand = core.BNLowLevelILSetExprSourceOperand
_BNLowLevelILSetExprSourceOperand.restype = None
_BNLowLevelILSetExprSourceOperand.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNLowLevelILSetExprSourceOperand(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int,
operand: int
) -> None:
return _BNLowLevelILSetExprSourceOperand(func, expr, operand)
# -------------------------------------------------------
# _BNLowLevelILSetIndirectBranches
_BNLowLevelILSetIndirectBranches = core.BNLowLevelILSetIndirectBranches
_BNLowLevelILSetIndirectBranches.restype = None
_BNLowLevelILSetIndirectBranches.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNArchitectureAndAddress),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNLowLevelILSetIndirectBranches(
func: ctypes.POINTER(BNLowLevelILFunction),
branches: ctypes.POINTER(BNArchitectureAndAddress),
count: int
) -> None:
return _BNLowLevelILSetIndirectBranches(func, branches, count)
# -------------------------------------------------------
# _BNMarkBasicBlockAsRecentlyUsed
_BNMarkBasicBlockAsRecentlyUsed = core.BNMarkBasicBlockAsRecentlyUsed
_BNMarkBasicBlockAsRecentlyUsed.restype = None
_BNMarkBasicBlockAsRecentlyUsed.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNMarkBasicBlockAsRecentlyUsed(
block: ctypes.POINTER(BNBasicBlock)
) -> None:
return _BNMarkBasicBlockAsRecentlyUsed(block)
# -------------------------------------------------------
# _BNMarkCallerUpdatesRequired
_BNMarkCallerUpdatesRequired = core.BNMarkCallerUpdatesRequired
_BNMarkCallerUpdatesRequired.restype = None
_BNMarkCallerUpdatesRequired.argtypes = [
ctypes.POINTER(BNFunction),
FunctionUpdateTypeEnum,
]
# noinspection PyPep8Naming
def BNMarkCallerUpdatesRequired(
func: ctypes.POINTER(BNFunction),
type: FunctionUpdateType
) -> None:
return _BNMarkCallerUpdatesRequired(func, type)
# -------------------------------------------------------
# _BNMarkFileModified
_BNMarkFileModified = core.BNMarkFileModified
_BNMarkFileModified.restype = None
_BNMarkFileModified.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNMarkFileModified(
file: ctypes.POINTER(BNFileMetadata)
) -> None:
return _BNMarkFileModified(file)
# -------------------------------------------------------
# _BNMarkFileSaved
_BNMarkFileSaved = core.BNMarkFileSaved
_BNMarkFileSaved.restype = None
_BNMarkFileSaved.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNMarkFileSaved(
file: ctypes.POINTER(BNFileMetadata)
) -> None:
return _BNMarkFileSaved(file)
# -------------------------------------------------------
# _BNMarkFunctionAsRecentlyUsed
_BNMarkFunctionAsRecentlyUsed = core.BNMarkFunctionAsRecentlyUsed
_BNMarkFunctionAsRecentlyUsed.restype = None
_BNMarkFunctionAsRecentlyUsed.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNMarkFunctionAsRecentlyUsed(
func: ctypes.POINTER(BNFunction)
) -> None:
return _BNMarkFunctionAsRecentlyUsed(func)
# -------------------------------------------------------
# _BNMarkMediumLevelILInstructionForRemoval
_BNMarkMediumLevelILInstructionForRemoval = core.BNMarkMediumLevelILInstructionForRemoval
_BNMarkMediumLevelILInstructionForRemoval.restype = None
_BNMarkMediumLevelILInstructionForRemoval.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMarkMediumLevelILInstructionForRemoval(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int
) -> None:
return _BNMarkMediumLevelILInstructionForRemoval(func, instr)
# -------------------------------------------------------
# _BNMarkUpdatesRequired
_BNMarkUpdatesRequired = core.BNMarkUpdatesRequired
_BNMarkUpdatesRequired.restype = None
_BNMarkUpdatesRequired.argtypes = [
ctypes.POINTER(BNFunction),
FunctionUpdateTypeEnum,
]
# noinspection PyPep8Naming
def BNMarkUpdatesRequired(
func: ctypes.POINTER(BNFunction),
type: FunctionUpdateType
) -> None:
return _BNMarkUpdatesRequired(func, type)
# -------------------------------------------------------
# _BNMarkdownToHTML
_BNMarkdownToHTML = core.BNMarkdownToHTML
_BNMarkdownToHTML.restype = ctypes.POINTER(ctypes.c_byte)
_BNMarkdownToHTML.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNMarkdownToHTML(
contents: Optional[str]
) -> Optional[Optional[str]]:
result = _BNMarkdownToHTML(cstr(contents))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNMediumLevelILAddExpr
_BNMediumLevelILAddExpr = core.BNMediumLevelILAddExpr
_BNMediumLevelILAddExpr.restype = ctypes.c_ulonglong
_BNMediumLevelILAddExpr.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
MediumLevelILOperationEnum,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMediumLevelILAddExpr(
func: ctypes.POINTER(BNMediumLevelILFunction),
operation: MediumLevelILOperation,
size: int,
a: int,
b: int,
c: int,
d: int,
e: int
) -> int:
return _BNMediumLevelILAddExpr(func, operation, size, a, b, c, d, e)
# -------------------------------------------------------
# _BNMediumLevelILAddExprWithLocation
_BNMediumLevelILAddExprWithLocation = core.BNMediumLevelILAddExprWithLocation
_BNMediumLevelILAddExprWithLocation.restype = ctypes.c_ulonglong
_BNMediumLevelILAddExprWithLocation.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
MediumLevelILOperationEnum,
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMediumLevelILAddExprWithLocation(
func: ctypes.POINTER(BNMediumLevelILFunction),
operation: MediumLevelILOperation,
addr: int,
sourceOperand: int,
size: int,
a: int,
b: int,
c: int,
d: int,
e: int
) -> int:
return _BNMediumLevelILAddExprWithLocation(func, operation, addr, sourceOperand, size, a, b, c, d, e)
# -------------------------------------------------------
# _BNMediumLevelILAddInstruction
_BNMediumLevelILAddInstruction = core.BNMediumLevelILAddInstruction
_BNMediumLevelILAddInstruction.restype = ctypes.c_ulonglong
_BNMediumLevelILAddInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMediumLevelILAddInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int
) -> int:
return _BNMediumLevelILAddInstruction(func, expr)
# -------------------------------------------------------
# _BNMediumLevelILAddLabelMap
_BNMediumLevelILAddLabelMap = core.BNMediumLevelILAddLabelMap
_BNMediumLevelILAddLabelMap.restype = ctypes.c_ulonglong
_BNMediumLevelILAddLabelMap.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.POINTER(BNMediumLevelILLabel)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMediumLevelILAddLabelMap(
func: ctypes.POINTER(BNMediumLevelILFunction),
values: ctypes.POINTER(ctypes.c_ulonglong),
labels: ctypes.POINTER(ctypes.POINTER(BNMediumLevelILLabel)),
count: int
) -> int:
return _BNMediumLevelILAddLabelMap(func, values, labels, count)
# -------------------------------------------------------
# _BNMediumLevelILAddOperandList
_BNMediumLevelILAddOperandList = core.BNMediumLevelILAddOperandList
_BNMediumLevelILAddOperandList.restype = ctypes.c_ulonglong
_BNMediumLevelILAddOperandList.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMediumLevelILAddOperandList(
func: ctypes.POINTER(BNMediumLevelILFunction),
operands: ctypes.POINTER(ctypes.c_ulonglong),
count: int
) -> int:
return _BNMediumLevelILAddOperandList(func, operands, count)
# -------------------------------------------------------
# _BNMediumLevelILFreeOperandList
_BNMediumLevelILFreeOperandList = core.BNMediumLevelILFreeOperandList
_BNMediumLevelILFreeOperandList.restype = None
_BNMediumLevelILFreeOperandList.argtypes = [
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNMediumLevelILFreeOperandList(
operands: ctypes.POINTER(ctypes.c_ulonglong)
) -> None:
return _BNMediumLevelILFreeOperandList(operands)
# -------------------------------------------------------
# _BNMediumLevelILGetCurrentAddress
_BNMediumLevelILGetCurrentAddress = core.BNMediumLevelILGetCurrentAddress
_BNMediumLevelILGetCurrentAddress.restype = ctypes.c_ulonglong
_BNMediumLevelILGetCurrentAddress.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNMediumLevelILGetCurrentAddress(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> int:
return _BNMediumLevelILGetCurrentAddress(func)
# -------------------------------------------------------
# _BNMediumLevelILGetInstructionStart
_BNMediumLevelILGetInstructionStart = core.BNMediumLevelILGetInstructionStart
_BNMediumLevelILGetInstructionStart.restype = ctypes.c_ulonglong
_BNMediumLevelILGetInstructionStart.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMediumLevelILGetInstructionStart(
func: ctypes.POINTER(BNMediumLevelILFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> int:
return _BNMediumLevelILGetInstructionStart(func, arch, addr)
# -------------------------------------------------------
# _BNMediumLevelILGetOperandList
_BNMediumLevelILGetOperandList = core.BNMediumLevelILGetOperandList
_BNMediumLevelILGetOperandList.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNMediumLevelILGetOperandList.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNMediumLevelILGetOperandList(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int,
operand: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNMediumLevelILGetOperandList(func, expr, operand, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNMediumLevelILGoto
_BNMediumLevelILGoto = core.BNMediumLevelILGoto
_BNMediumLevelILGoto.restype = ctypes.c_ulonglong
_BNMediumLevelILGoto.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNMediumLevelILLabel),
]
# noinspection PyPep8Naming
def BNMediumLevelILGoto(
func: ctypes.POINTER(BNMediumLevelILFunction),
label: ctypes.POINTER(BNMediumLevelILLabel)
) -> int:
return _BNMediumLevelILGoto(func, label)
# -------------------------------------------------------
# _BNMediumLevelILGotoWithLocation
_BNMediumLevelILGotoWithLocation = core.BNMediumLevelILGotoWithLocation
_BNMediumLevelILGotoWithLocation.restype = ctypes.c_ulonglong
_BNMediumLevelILGotoWithLocation.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNMediumLevelILLabel),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNMediumLevelILGotoWithLocation(
func: ctypes.POINTER(BNMediumLevelILFunction),
label: ctypes.POINTER(BNMediumLevelILLabel),
addr: int,
sourceOperand: int
) -> int:
return _BNMediumLevelILGotoWithLocation(func, label, addr, sourceOperand)
# -------------------------------------------------------
# _BNMediumLevelILIf
_BNMediumLevelILIf = core.BNMediumLevelILIf
_BNMediumLevelILIf.restype = ctypes.c_ulonglong
_BNMediumLevelILIf.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(BNMediumLevelILLabel),
ctypes.POINTER(BNMediumLevelILLabel),
]
# noinspection PyPep8Naming
def BNMediumLevelILIf(
func: ctypes.POINTER(BNMediumLevelILFunction),
op: int,
t: ctypes.POINTER(BNMediumLevelILLabel),
f: ctypes.POINTER(BNMediumLevelILLabel)
) -> int:
return _BNMediumLevelILIf(func, op, t, f)
# -------------------------------------------------------
# _BNMediumLevelILIfWithLocation
_BNMediumLevelILIfWithLocation = core.BNMediumLevelILIfWithLocation
_BNMediumLevelILIfWithLocation.restype = ctypes.c_ulonglong
_BNMediumLevelILIfWithLocation.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(BNMediumLevelILLabel),
ctypes.POINTER(BNMediumLevelILLabel),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNMediumLevelILIfWithLocation(
func: ctypes.POINTER(BNMediumLevelILFunction),
op: int,
t: ctypes.POINTER(BNMediumLevelILLabel),
f: ctypes.POINTER(BNMediumLevelILLabel),
addr: int,
sourceOperand: int
) -> int:
return _BNMediumLevelILIfWithLocation(func, op, t, f, addr, sourceOperand)
# -------------------------------------------------------
# _BNMediumLevelILInitLabel
_BNMediumLevelILInitLabel = core.BNMediumLevelILInitLabel
_BNMediumLevelILInitLabel.restype = None
_BNMediumLevelILInitLabel.argtypes = [
ctypes.POINTER(BNMediumLevelILLabel),
]
# noinspection PyPep8Naming
def BNMediumLevelILInitLabel(
label: ctypes.POINTER(BNMediumLevelILLabel)
) -> None:
return _BNMediumLevelILInitLabel(label)
# -------------------------------------------------------
# _BNMediumLevelILMarkLabel
_BNMediumLevelILMarkLabel = core.BNMediumLevelILMarkLabel
_BNMediumLevelILMarkLabel.restype = None
_BNMediumLevelILMarkLabel.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNMediumLevelILLabel),
]
# noinspection PyPep8Naming
def BNMediumLevelILMarkLabel(
func: ctypes.POINTER(BNMediumLevelILFunction),
label: ctypes.POINTER(BNMediumLevelILLabel)
) -> None:
return _BNMediumLevelILMarkLabel(func, label)
# -------------------------------------------------------
# _BNMediumLevelILSetCurrentAddress
_BNMediumLevelILSetCurrentAddress = core.BNMediumLevelILSetCurrentAddress
_BNMediumLevelILSetCurrentAddress.restype = None
_BNMediumLevelILSetCurrentAddress.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMediumLevelILSetCurrentAddress(
func: ctypes.POINTER(BNMediumLevelILFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int
) -> None:
return _BNMediumLevelILSetCurrentAddress(func, arch, addr)
# -------------------------------------------------------
# _BNMergeVariables
_BNMergeVariables = core.BNMergeVariables
_BNMergeVariables.restype = None
_BNMergeVariables.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMergeVariables(
func: ctypes.POINTER(BNFunction),
target: ctypes.POINTER(BNVariable),
sources: ctypes.POINTER(BNVariable),
sourceCount: int
) -> None:
return _BNMergeVariables(func, target, sources, sourceCount)
# -------------------------------------------------------
# _BNMetadataArrayAppend
_BNMetadataArrayAppend = core.BNMetadataArrayAppend
_BNMetadataArrayAppend.restype = ctypes.c_bool
_BNMetadataArrayAppend.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataArrayAppend(
data: ctypes.POINTER(BNMetadata),
md: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataArrayAppend(data, md)
# -------------------------------------------------------
# _BNMetadataGetArray
_BNMetadataGetArray = core.BNMetadataGetArray
_BNMetadataGetArray.restype = ctypes.POINTER(ctypes.POINTER(BNMetadata))
_BNMetadataGetArray.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNMetadataGetArray(
data: ctypes.POINTER(BNMetadata),
size: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNMetadata))]:
result = _BNMetadataGetArray(data, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNMetadataGetBoolean
_BNMetadataGetBoolean = core.BNMetadataGetBoolean
_BNMetadataGetBoolean.restype = ctypes.c_bool
_BNMetadataGetBoolean.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataGetBoolean(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataGetBoolean(data)
# -------------------------------------------------------
# _BNMetadataGetBooleanList
_BNMetadataGetBooleanList = core.BNMetadataGetBooleanList
_BNMetadataGetBooleanList.restype = ctypes.POINTER(ctypes.c_bool)
_BNMetadataGetBooleanList.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNMetadataGetBooleanList(
data: ctypes.POINTER(BNMetadata),
arg1: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_bool)]:
result = _BNMetadataGetBooleanList(data, arg1)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNMetadataGetDouble
_BNMetadataGetDouble = core.BNMetadataGetDouble
_BNMetadataGetDouble.restype = ctypes.c_double
_BNMetadataGetDouble.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataGetDouble(
data: ctypes.POINTER(BNMetadata)
) -> float:
return _BNMetadataGetDouble(data)
# -------------------------------------------------------
# _BNMetadataGetDoubleList
_BNMetadataGetDoubleList = core.BNMetadataGetDoubleList
_BNMetadataGetDoubleList.restype = ctypes.POINTER(ctypes.c_double)
_BNMetadataGetDoubleList.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNMetadataGetDoubleList(
data: ctypes.POINTER(BNMetadata),
arg1: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_double)]:
result = _BNMetadataGetDoubleList(data, arg1)
if not result:
return None
return result
# -------------------------------------------------------
# _BNMetadataGetForIndex
_BNMetadataGetForIndex = core.BNMetadataGetForIndex
_BNMetadataGetForIndex.restype = ctypes.POINTER(BNMetadata)
_BNMetadataGetForIndex.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMetadataGetForIndex(
data: ctypes.POINTER(BNMetadata),
index: int
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNMetadataGetForIndex(data, index)
if not result:
return None
return result
# -------------------------------------------------------
# _BNMetadataGetForKey
_BNMetadataGetForKey = core.BNMetadataGetForKey
_BNMetadataGetForKey.restype = ctypes.POINTER(BNMetadata)
_BNMetadataGetForKey.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNMetadataGetForKey(
data: ctypes.POINTER(BNMetadata),
key: Optional[str]
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNMetadataGetForKey(data, cstr(key))
if not result:
return None
return result
# -------------------------------------------------------
# _BNMetadataGetRaw
_BNMetadataGetRaw = core.BNMetadataGetRaw
_BNMetadataGetRaw.restype = ctypes.POINTER(ctypes.c_ubyte)
_BNMetadataGetRaw.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNMetadataGetRaw(
data: ctypes.POINTER(BNMetadata),
size: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ubyte)]:
result = _BNMetadataGetRaw(data, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNMetadataGetSignedInteger
_BNMetadataGetSignedInteger = core.BNMetadataGetSignedInteger
_BNMetadataGetSignedInteger.restype = ctypes.c_longlong
_BNMetadataGetSignedInteger.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataGetSignedInteger(
data: ctypes.POINTER(BNMetadata)
) -> int:
return _BNMetadataGetSignedInteger(data)
# -------------------------------------------------------
# _BNMetadataGetSignedIntegerList
_BNMetadataGetSignedIntegerList = core.BNMetadataGetSignedIntegerList
_BNMetadataGetSignedIntegerList.restype = ctypes.POINTER(ctypes.c_longlong)
_BNMetadataGetSignedIntegerList.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNMetadataGetSignedIntegerList(
data: ctypes.POINTER(BNMetadata),
arg1: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_longlong)]:
result = _BNMetadataGetSignedIntegerList(data, arg1)
if not result:
return None
return result
# -------------------------------------------------------
# _BNMetadataGetString
_BNMetadataGetString = core.BNMetadataGetString
_BNMetadataGetString.restype = ctypes.POINTER(ctypes.c_byte)
_BNMetadataGetString.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataGetString(
data: ctypes.POINTER(BNMetadata)
) -> Optional[Optional[str]]:
result = _BNMetadataGetString(data)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNMetadataGetStringList
_BNMetadataGetStringList = core.BNMetadataGetStringList
_BNMetadataGetStringList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNMetadataGetStringList.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNMetadataGetStringList(
data: ctypes.POINTER(BNMetadata),
arg1: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNMetadataGetStringList(data, arg1)
if not result:
return None
return result
# -------------------------------------------------------
# _BNMetadataGetType
_BNMetadataGetType = core.BNMetadataGetType
_BNMetadataGetType.restype = MetadataTypeEnum
_BNMetadataGetType.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataGetType(
data: ctypes.POINTER(BNMetadata)
) -> MetadataType:
return _BNMetadataGetType(data)
# -------------------------------------------------------
# _BNMetadataGetUnsignedInteger
_BNMetadataGetUnsignedInteger = core.BNMetadataGetUnsignedInteger
_BNMetadataGetUnsignedInteger.restype = ctypes.c_ulonglong
_BNMetadataGetUnsignedInteger.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataGetUnsignedInteger(
data: ctypes.POINTER(BNMetadata)
) -> int:
return _BNMetadataGetUnsignedInteger(data)
# -------------------------------------------------------
# _BNMetadataGetUnsignedIntegerList
_BNMetadataGetUnsignedIntegerList = core.BNMetadataGetUnsignedIntegerList
_BNMetadataGetUnsignedIntegerList.restype = ctypes.POINTER(ctypes.c_ulonglong)
_BNMetadataGetUnsignedIntegerList.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNMetadataGetUnsignedIntegerList(
data: ctypes.POINTER(BNMetadata),
arg1: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_ulonglong)]:
result = _BNMetadataGetUnsignedIntegerList(data, arg1)
if not result:
return None
return result
# -------------------------------------------------------
# _BNMetadataGetValueStore
_BNMetadataGetValueStore = core.BNMetadataGetValueStore
_BNMetadataGetValueStore.restype = ctypes.POINTER(BNMetadataValueStore)
_BNMetadataGetValueStore.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataGetValueStore(
data: ctypes.POINTER(BNMetadata)
) -> Optional[ctypes.POINTER(BNMetadataValueStore)]:
result = _BNMetadataGetValueStore(data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNMetadataIsArray
_BNMetadataIsArray = core.BNMetadataIsArray
_BNMetadataIsArray.restype = ctypes.c_bool
_BNMetadataIsArray.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsArray(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsArray(data)
# -------------------------------------------------------
# _BNMetadataIsBoolean
_BNMetadataIsBoolean = core.BNMetadataIsBoolean
_BNMetadataIsBoolean.restype = ctypes.c_bool
_BNMetadataIsBoolean.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsBoolean(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsBoolean(data)
# -------------------------------------------------------
# _BNMetadataIsBooleanList
_BNMetadataIsBooleanList = core.BNMetadataIsBooleanList
_BNMetadataIsBooleanList.restype = ctypes.c_bool
_BNMetadataIsBooleanList.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsBooleanList(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsBooleanList(data)
# -------------------------------------------------------
# _BNMetadataIsDouble
_BNMetadataIsDouble = core.BNMetadataIsDouble
_BNMetadataIsDouble.restype = ctypes.c_bool
_BNMetadataIsDouble.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsDouble(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsDouble(data)
# -------------------------------------------------------
# _BNMetadataIsDoubleList
_BNMetadataIsDoubleList = core.BNMetadataIsDoubleList
_BNMetadataIsDoubleList.restype = ctypes.c_bool
_BNMetadataIsDoubleList.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsDoubleList(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsDoubleList(data)
# -------------------------------------------------------
# _BNMetadataIsEqual
_BNMetadataIsEqual = core.BNMetadataIsEqual
_BNMetadataIsEqual.restype = ctypes.c_bool
_BNMetadataIsEqual.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsEqual(
lhs: ctypes.POINTER(BNMetadata),
rhs: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsEqual(lhs, rhs)
# -------------------------------------------------------
# _BNMetadataIsKeyValueStore
_BNMetadataIsKeyValueStore = core.BNMetadataIsKeyValueStore
_BNMetadataIsKeyValueStore.restype = ctypes.c_bool
_BNMetadataIsKeyValueStore.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsKeyValueStore(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsKeyValueStore(data)
# -------------------------------------------------------
# _BNMetadataIsRaw
_BNMetadataIsRaw = core.BNMetadataIsRaw
_BNMetadataIsRaw.restype = ctypes.c_bool
_BNMetadataIsRaw.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsRaw(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsRaw(data)
# -------------------------------------------------------
# _BNMetadataIsSignedInteger
_BNMetadataIsSignedInteger = core.BNMetadataIsSignedInteger
_BNMetadataIsSignedInteger.restype = ctypes.c_bool
_BNMetadataIsSignedInteger.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsSignedInteger(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsSignedInteger(data)
# -------------------------------------------------------
# _BNMetadataIsSignedIntegerList
_BNMetadataIsSignedIntegerList = core.BNMetadataIsSignedIntegerList
_BNMetadataIsSignedIntegerList.restype = ctypes.c_bool
_BNMetadataIsSignedIntegerList.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsSignedIntegerList(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsSignedIntegerList(data)
# -------------------------------------------------------
# _BNMetadataIsString
_BNMetadataIsString = core.BNMetadataIsString
_BNMetadataIsString.restype = ctypes.c_bool
_BNMetadataIsString.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsString(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsString(data)
# -------------------------------------------------------
# _BNMetadataIsStringList
_BNMetadataIsStringList = core.BNMetadataIsStringList
_BNMetadataIsStringList.restype = ctypes.c_bool
_BNMetadataIsStringList.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsStringList(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsStringList(data)
# -------------------------------------------------------
# _BNMetadataIsUnsignedInteger
_BNMetadataIsUnsignedInteger = core.BNMetadataIsUnsignedInteger
_BNMetadataIsUnsignedInteger.restype = ctypes.c_bool
_BNMetadataIsUnsignedInteger.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsUnsignedInteger(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsUnsignedInteger(data)
# -------------------------------------------------------
# _BNMetadataIsUnsignedIntegerList
_BNMetadataIsUnsignedIntegerList = core.BNMetadataIsUnsignedIntegerList
_BNMetadataIsUnsignedIntegerList.restype = ctypes.c_bool
_BNMetadataIsUnsignedIntegerList.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataIsUnsignedIntegerList(
data: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataIsUnsignedIntegerList(data)
# -------------------------------------------------------
# _BNMetadataRemoveIndex
_BNMetadataRemoveIndex = core.BNMetadataRemoveIndex
_BNMetadataRemoveIndex.restype = None
_BNMetadataRemoveIndex.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNMetadataRemoveIndex(
data: ctypes.POINTER(BNMetadata),
index: int
) -> None:
return _BNMetadataRemoveIndex(data, index)
# -------------------------------------------------------
# _BNMetadataRemoveKey
_BNMetadataRemoveKey = core.BNMetadataRemoveKey
_BNMetadataRemoveKey.restype = None
_BNMetadataRemoveKey.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNMetadataRemoveKey(
data: ctypes.POINTER(BNMetadata),
key: Optional[str]
) -> None:
return _BNMetadataRemoveKey(data, cstr(key))
# -------------------------------------------------------
# _BNMetadataSetValueForKey
_BNMetadataSetValueForKey = core.BNMetadataSetValueForKey
_BNMetadataSetValueForKey.restype = ctypes.c_bool
_BNMetadataSetValueForKey.argtypes = [
ctypes.POINTER(BNMetadata),
ctypes.c_char_p,
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataSetValueForKey(
data: ctypes.POINTER(BNMetadata),
key: Optional[str],
md: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNMetadataSetValueForKey(data, cstr(key), md)
# -------------------------------------------------------
# _BNMetadataSize
_BNMetadataSize = core.BNMetadataSize
_BNMetadataSize.restype = ctypes.c_ulonglong
_BNMetadataSize.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNMetadataSize(
data: ctypes.POINTER(BNMetadata)
) -> int:
return _BNMetadataSize(data)
# -------------------------------------------------------
# _BNNavigate
_BNNavigate = core.BNNavigate
_BNNavigate.restype = ctypes.c_bool
_BNNavigate.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNNavigate(
file: ctypes.POINTER(BNFileMetadata),
view: Optional[str],
offset: int
) -> bool:
return _BNNavigate(file, cstr(view), offset)
# -------------------------------------------------------
# _BNNewActivityReference
_BNNewActivityReference = core.BNNewActivityReference
_BNNewActivityReference.restype = ctypes.POINTER(BNActivity)
_BNNewActivityReference.argtypes = [
ctypes.POINTER(BNActivity),
]
# noinspection PyPep8Naming
def BNNewActivityReference(
activity: ctypes.POINTER(BNActivity)
) -> Optional[ctypes.POINTER(BNActivity)]:
result = _BNNewActivityReference(activity)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewAnalysisCompletionEventReference
_BNNewAnalysisCompletionEventReference = core.BNNewAnalysisCompletionEventReference
_BNNewAnalysisCompletionEventReference.restype = ctypes.POINTER(BNAnalysisCompletionEvent)
_BNNewAnalysisCompletionEventReference.argtypes = [
ctypes.POINTER(BNAnalysisCompletionEvent),
]
# noinspection PyPep8Naming
def BNNewAnalysisCompletionEventReference(
event: ctypes.POINTER(BNAnalysisCompletionEvent)
) -> Optional[ctypes.POINTER(BNAnalysisCompletionEvent)]:
result = _BNNewAnalysisCompletionEventReference(event)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewAnalysisContextReference
_BNNewAnalysisContextReference = core.BNNewAnalysisContextReference
_BNNewAnalysisContextReference.restype = ctypes.POINTER(BNAnalysisContext)
_BNNewAnalysisContextReference.argtypes = [
ctypes.POINTER(BNAnalysisContext),
]
# noinspection PyPep8Naming
def BNNewAnalysisContextReference(
analysisContext: ctypes.POINTER(BNAnalysisContext)
) -> Optional[ctypes.POINTER(BNAnalysisContext)]:
result = _BNNewAnalysisContextReference(analysisContext)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewBackgroundTaskReference
_BNNewBackgroundTaskReference = core.BNNewBackgroundTaskReference
_BNNewBackgroundTaskReference.restype = ctypes.POINTER(BNBackgroundTask)
_BNNewBackgroundTaskReference.argtypes = [
ctypes.POINTER(BNBackgroundTask),
]
# noinspection PyPep8Naming
def BNNewBackgroundTaskReference(
task: ctypes.POINTER(BNBackgroundTask)
) -> Optional[ctypes.POINTER(BNBackgroundTask)]:
result = _BNNewBackgroundTaskReference(task)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewBasicBlockReference
_BNNewBasicBlockReference = core.BNNewBasicBlockReference
_BNNewBasicBlockReference.restype = ctypes.POINTER(BNBasicBlock)
_BNNewBasicBlockReference.argtypes = [
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNNewBasicBlockReference(
block: ctypes.POINTER(BNBasicBlock)
) -> Optional[ctypes.POINTER(BNBasicBlock)]:
result = _BNNewBasicBlockReference(block)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewCallingConventionReference
_BNNewCallingConventionReference = core.BNNewCallingConventionReference
_BNNewCallingConventionReference.restype = ctypes.POINTER(BNCallingConvention)
_BNNewCallingConventionReference.argtypes = [
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNNewCallingConventionReference(
cc: ctypes.POINTER(BNCallingConvention)
) -> Optional[ctypes.POINTER(BNCallingConvention)]:
result = _BNNewCallingConventionReference(cc)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewComponentReference
_BNNewComponentReference = core.BNNewComponentReference
_BNNewComponentReference.restype = ctypes.POINTER(BNComponent)
_BNNewComponentReference.argtypes = [
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNNewComponentReference(
component: ctypes.POINTER(BNComponent)
) -> Optional[ctypes.POINTER(BNComponent)]:
result = _BNNewComponentReference(component)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewDataRendererReference
_BNNewDataRendererReference = core.BNNewDataRendererReference
_BNNewDataRendererReference.restype = ctypes.POINTER(BNDataRenderer)
_BNNewDataRendererReference.argtypes = [
ctypes.POINTER(BNDataRenderer),
]
# noinspection PyPep8Naming
def BNNewDataRendererReference(
renderer: ctypes.POINTER(BNDataRenderer)
) -> Optional[ctypes.POINTER(BNDataRenderer)]:
result = _BNNewDataRendererReference(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewDatabaseReference
_BNNewDatabaseReference = core.BNNewDatabaseReference
_BNNewDatabaseReference.restype = ctypes.POINTER(BNDatabase)
_BNNewDatabaseReference.argtypes = [
ctypes.POINTER(BNDatabase),
]
# noinspection PyPep8Naming
def BNNewDatabaseReference(
database: ctypes.POINTER(BNDatabase)
) -> Optional[ctypes.POINTER(BNDatabase)]:
result = _BNNewDatabaseReference(database)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewDebugInfoParserReference
_BNNewDebugInfoParserReference = core.BNNewDebugInfoParserReference
_BNNewDebugInfoParserReference.restype = ctypes.POINTER(BNDebugInfoParser)
_BNNewDebugInfoParserReference.argtypes = [
ctypes.POINTER(BNDebugInfoParser),
]
# noinspection PyPep8Naming
def BNNewDebugInfoParserReference(
parser: ctypes.POINTER(BNDebugInfoParser)
) -> Optional[ctypes.POINTER(BNDebugInfoParser)]:
result = _BNNewDebugInfoParserReference(parser)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewDebugInfoReference
_BNNewDebugInfoReference = core.BNNewDebugInfoReference
_BNNewDebugInfoReference.restype = ctypes.POINTER(BNDebugInfo)
_BNNewDebugInfoReference.argtypes = [
ctypes.POINTER(BNDebugInfo),
]
# noinspection PyPep8Naming
def BNNewDebugInfoReference(
debugInfo: ctypes.POINTER(BNDebugInfo)
) -> Optional[ctypes.POINTER(BNDebugInfo)]:
result = _BNNewDebugInfoReference(debugInfo)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewDisassemblySettingsReference
_BNNewDisassemblySettingsReference = core.BNNewDisassemblySettingsReference
_BNNewDisassemblySettingsReference.restype = ctypes.POINTER(BNDisassemblySettings)
_BNNewDisassemblySettingsReference.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNNewDisassemblySettingsReference(
settings: ctypes.POINTER(BNDisassemblySettings)
) -> Optional[ctypes.POINTER(BNDisassemblySettings)]:
result = _BNNewDisassemblySettingsReference(settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewDisassemblyTextRendererReference
_BNNewDisassemblyTextRendererReference = core.BNNewDisassemblyTextRendererReference
_BNNewDisassemblyTextRendererReference.restype = ctypes.POINTER(BNDisassemblyTextRenderer)
_BNNewDisassemblyTextRendererReference.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNNewDisassemblyTextRendererReference(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> Optional[ctypes.POINTER(BNDisassemblyTextRenderer)]:
result = _BNNewDisassemblyTextRendererReference(renderer)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewDownloadInstanceReference
_BNNewDownloadInstanceReference = core.BNNewDownloadInstanceReference
_BNNewDownloadInstanceReference.restype = ctypes.POINTER(BNDownloadInstance)
_BNNewDownloadInstanceReference.argtypes = [
ctypes.POINTER(BNDownloadInstance),
]
# noinspection PyPep8Naming
def BNNewDownloadInstanceReference(
instance: ctypes.POINTER(BNDownloadInstance)
) -> Optional[ctypes.POINTER(BNDownloadInstance)]:
result = _BNNewDownloadInstanceReference(instance)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewEnumerationReference
_BNNewEnumerationReference = core.BNNewEnumerationReference
_BNNewEnumerationReference.restype = ctypes.POINTER(BNEnumeration)
_BNNewEnumerationReference.argtypes = [
ctypes.POINTER(BNEnumeration),
]
# noinspection PyPep8Naming
def BNNewEnumerationReference(
e: ctypes.POINTER(BNEnumeration)
) -> Optional[ctypes.POINTER(BNEnumeration)]:
result = _BNNewEnumerationReference(e)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewExternalLibraryReference
_BNNewExternalLibraryReference = core.BNNewExternalLibraryReference
_BNNewExternalLibraryReference.restype = ctypes.POINTER(BNExternalLibrary)
_BNNewExternalLibraryReference.argtypes = [
ctypes.POINTER(BNExternalLibrary),
]
# noinspection PyPep8Naming
def BNNewExternalLibraryReference(
lib: ctypes.POINTER(BNExternalLibrary)
) -> Optional[ctypes.POINTER(BNExternalLibrary)]:
result = _BNNewExternalLibraryReference(lib)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewExternalLocationReference
_BNNewExternalLocationReference = core.BNNewExternalLocationReference
_BNNewExternalLocationReference.restype = ctypes.POINTER(BNExternalLocation)
_BNNewExternalLocationReference.argtypes = [
ctypes.POINTER(BNExternalLocation),
]
# noinspection PyPep8Naming
def BNNewExternalLocationReference(
loc: ctypes.POINTER(BNExternalLocation)
) -> Optional[ctypes.POINTER(BNExternalLocation)]:
result = _BNNewExternalLocationReference(loc)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewFileReference
_BNNewFileReference = core.BNNewFileReference
_BNNewFileReference.restype = ctypes.POINTER(BNFileMetadata)
_BNNewFileReference.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNNewFileReference(
file: ctypes.POINTER(BNFileMetadata)
) -> Optional[ctypes.POINTER(BNFileMetadata)]:
result = _BNNewFileReference(file)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewFlowGraphLayoutRequestReference
_BNNewFlowGraphLayoutRequestReference = core.BNNewFlowGraphLayoutRequestReference
_BNNewFlowGraphLayoutRequestReference.restype = ctypes.POINTER(BNFlowGraphLayoutRequest)
_BNNewFlowGraphLayoutRequestReference.argtypes = [
ctypes.POINTER(BNFlowGraphLayoutRequest),
]
# noinspection PyPep8Naming
def BNNewFlowGraphLayoutRequestReference(
layout: ctypes.POINTER(BNFlowGraphLayoutRequest)
) -> Optional[ctypes.POINTER(BNFlowGraphLayoutRequest)]:
result = _BNNewFlowGraphLayoutRequestReference(layout)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewFlowGraphNodeReference
_BNNewFlowGraphNodeReference = core.BNNewFlowGraphNodeReference
_BNNewFlowGraphNodeReference.restype = ctypes.POINTER(BNFlowGraphNode)
_BNNewFlowGraphNodeReference.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
]
# noinspection PyPep8Naming
def BNNewFlowGraphNodeReference(
node: ctypes.POINTER(BNFlowGraphNode)
) -> Optional[ctypes.POINTER(BNFlowGraphNode)]:
result = _BNNewFlowGraphNodeReference(node)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewFlowGraphReference
_BNNewFlowGraphReference = core.BNNewFlowGraphReference
_BNNewFlowGraphReference.restype = ctypes.POINTER(BNFlowGraph)
_BNNewFlowGraphReference.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNNewFlowGraphReference(
graph: ctypes.POINTER(BNFlowGraph)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNNewFlowGraphReference(graph)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewFunctionReference
_BNNewFunctionReference = core.BNNewFunctionReference
_BNNewFunctionReference.restype = ctypes.POINTER(BNFunction)
_BNNewFunctionReference.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNNewFunctionReference(
func: ctypes.POINTER(BNFunction)
) -> Optional[ctypes.POINTER(BNFunction)]:
result = _BNNewFunctionReference(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewHighLevelILFunctionReference
_BNNewHighLevelILFunctionReference = core.BNNewHighLevelILFunctionReference
_BNNewHighLevelILFunctionReference.restype = ctypes.POINTER(BNHighLevelILFunction)
_BNNewHighLevelILFunctionReference.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNNewHighLevelILFunctionReference(
func: ctypes.POINTER(BNHighLevelILFunction)
) -> Optional[ctypes.POINTER(BNHighLevelILFunction)]:
result = _BNNewHighLevelILFunctionReference(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewKeyValueStoreReference
_BNNewKeyValueStoreReference = core.BNNewKeyValueStoreReference
_BNNewKeyValueStoreReference.restype = ctypes.POINTER(BNKeyValueStore)
_BNNewKeyValueStoreReference.argtypes = [
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNNewKeyValueStoreReference(
store: ctypes.POINTER(BNKeyValueStore)
) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
result = _BNNewKeyValueStoreReference(store)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewLanguageRepresentationFunctionReference
_BNNewLanguageRepresentationFunctionReference = core.BNNewLanguageRepresentationFunctionReference
_BNNewLanguageRepresentationFunctionReference.restype = ctypes.POINTER(BNLanguageRepresentationFunction)
_BNNewLanguageRepresentationFunctionReference.argtypes = [
ctypes.POINTER(BNLanguageRepresentationFunction),
]
# noinspection PyPep8Naming
def BNNewLanguageRepresentationFunctionReference(
func: ctypes.POINTER(BNLanguageRepresentationFunction)
) -> Optional[ctypes.POINTER(BNLanguageRepresentationFunction)]:
result = _BNNewLanguageRepresentationFunctionReference(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewLinearViewCursorReference
_BNNewLinearViewCursorReference = core.BNNewLinearViewCursorReference
_BNNewLinearViewCursorReference.restype = ctypes.POINTER(BNLinearViewCursor)
_BNNewLinearViewCursorReference.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNNewLinearViewCursorReference(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> Optional[ctypes.POINTER(BNLinearViewCursor)]:
result = _BNNewLinearViewCursorReference(cursor)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewLinearViewObjectReference
_BNNewLinearViewObjectReference = core.BNNewLinearViewObjectReference
_BNNewLinearViewObjectReference.restype = ctypes.POINTER(BNLinearViewObject)
_BNNewLinearViewObjectReference.argtypes = [
ctypes.POINTER(BNLinearViewObject),
]
# noinspection PyPep8Naming
def BNNewLinearViewObjectReference(
obj: ctypes.POINTER(BNLinearViewObject)
) -> Optional[ctypes.POINTER(BNLinearViewObject)]:
result = _BNNewLinearViewObjectReference(obj)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewLoggerReference
_BNNewLoggerReference = core.BNNewLoggerReference
_BNNewLoggerReference.restype = ctypes.POINTER(BNLogger)
_BNNewLoggerReference.argtypes = [
ctypes.POINTER(BNLogger),
]
# noinspection PyPep8Naming
def BNNewLoggerReference(
logger: ctypes.POINTER(BNLogger)
) -> Optional[ctypes.POINTER(BNLogger)]:
result = _BNNewLoggerReference(logger)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewLowLevelILFunctionReference
_BNNewLowLevelILFunctionReference = core.BNNewLowLevelILFunctionReference
_BNNewLowLevelILFunctionReference.restype = ctypes.POINTER(BNLowLevelILFunction)
_BNNewLowLevelILFunctionReference.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNNewLowLevelILFunctionReference(
func: ctypes.POINTER(BNLowLevelILFunction)
) -> Optional[ctypes.POINTER(BNLowLevelILFunction)]:
result = _BNNewLowLevelILFunctionReference(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewMainThreadActionReference
_BNNewMainThreadActionReference = core.BNNewMainThreadActionReference
_BNNewMainThreadActionReference.restype = ctypes.POINTER(BNMainThreadAction)
_BNNewMainThreadActionReference.argtypes = [
ctypes.POINTER(BNMainThreadAction),
]
# noinspection PyPep8Naming
def BNNewMainThreadActionReference(
action: ctypes.POINTER(BNMainThreadAction)
) -> Optional[ctypes.POINTER(BNMainThreadAction)]:
result = _BNNewMainThreadActionReference(action)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewMediumLevelILFunctionReference
_BNNewMediumLevelILFunctionReference = core.BNNewMediumLevelILFunctionReference
_BNNewMediumLevelILFunctionReference.restype = ctypes.POINTER(BNMediumLevelILFunction)
_BNNewMediumLevelILFunctionReference.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNNewMediumLevelILFunctionReference(
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> Optional[ctypes.POINTER(BNMediumLevelILFunction)]:
result = _BNNewMediumLevelILFunctionReference(func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewMetadataReference
_BNNewMetadataReference = core.BNNewMetadataReference
_BNNewMetadataReference.restype = ctypes.POINTER(BNMetadata)
_BNNewMetadataReference.argtypes = [
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNNewMetadataReference(
data: ctypes.POINTER(BNMetadata)
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNNewMetadataReference(data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewNamedTypeReference
_BNNewNamedTypeReference = core.BNNewNamedTypeReference
_BNNewNamedTypeReference.restype = ctypes.POINTER(BNNamedTypeReference)
_BNNewNamedTypeReference.argtypes = [
ctypes.POINTER(BNNamedTypeReference),
]
# noinspection PyPep8Naming
def BNNewNamedTypeReference(
nt: ctypes.POINTER(BNNamedTypeReference)
) -> Optional[ctypes.POINTER(BNNamedTypeReference)]:
result = _BNNewNamedTypeReference(nt)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewPlatformReference
_BNNewPlatformReference = core.BNNewPlatformReference
_BNNewPlatformReference.restype = ctypes.POINTER(BNPlatform)
_BNNewPlatformReference.argtypes = [
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNNewPlatformReference(
platform: ctypes.POINTER(BNPlatform)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNNewPlatformReference(platform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewPluginReference
_BNNewPluginReference = core.BNNewPluginReference
_BNNewPluginReference.restype = ctypes.POINTER(BNRepoPlugin)
_BNNewPluginReference.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNNewPluginReference(
r: ctypes.POINTER(BNRepoPlugin)
) -> Optional[ctypes.POINTER(BNRepoPlugin)]:
result = _BNNewPluginReference(r)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewProjectFileReference
_BNNewProjectFileReference = core.BNNewProjectFileReference
_BNNewProjectFileReference.restype = ctypes.POINTER(BNProjectFile)
_BNNewProjectFileReference.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNNewProjectFileReference(
file: ctypes.POINTER(BNProjectFile)
) -> Optional[ctypes.POINTER(BNProjectFile)]:
result = _BNNewProjectFileReference(file)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewProjectFolderReference
_BNNewProjectFolderReference = core.BNNewProjectFolderReference
_BNNewProjectFolderReference.restype = ctypes.POINTER(BNProjectFolder)
_BNNewProjectFolderReference.argtypes = [
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNNewProjectFolderReference(
folder: ctypes.POINTER(BNProjectFolder)
) -> Optional[ctypes.POINTER(BNProjectFolder)]:
result = _BNNewProjectFolderReference(folder)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewProjectReference
_BNNewProjectReference = core.BNNewProjectReference
_BNNewProjectReference.restype = ctypes.POINTER(BNProject)
_BNNewProjectReference.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNNewProjectReference(
project: ctypes.POINTER(BNProject)
) -> Optional[ctypes.POINTER(BNProject)]:
result = _BNNewProjectReference(project)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewRelocationHandlerReference
_BNNewRelocationHandlerReference = core.BNNewRelocationHandlerReference
_BNNewRelocationHandlerReference.restype = ctypes.POINTER(BNRelocationHandler)
_BNNewRelocationHandlerReference.argtypes = [
ctypes.POINTER(BNRelocationHandler),
]
# noinspection PyPep8Naming
def BNNewRelocationHandlerReference(
handler: ctypes.POINTER(BNRelocationHandler)
) -> Optional[ctypes.POINTER(BNRelocationHandler)]:
result = _BNNewRelocationHandlerReference(handler)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewRelocationReference
_BNNewRelocationReference = core.BNNewRelocationReference
_BNNewRelocationReference.restype = ctypes.POINTER(BNRelocation)
_BNNewRelocationReference.argtypes = [
ctypes.POINTER(BNRelocation),
]
# noinspection PyPep8Naming
def BNNewRelocationReference(
reloc: ctypes.POINTER(BNRelocation)
) -> Optional[ctypes.POINTER(BNRelocation)]:
result = _BNNewRelocationReference(reloc)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewReportCollectionReference
_BNNewReportCollectionReference = core.BNNewReportCollectionReference
_BNNewReportCollectionReference.restype = ctypes.POINTER(BNReportCollection)
_BNNewReportCollectionReference.argtypes = [
ctypes.POINTER(BNReportCollection),
]
# noinspection PyPep8Naming
def BNNewReportCollectionReference(
reports: ctypes.POINTER(BNReportCollection)
) -> Optional[ctypes.POINTER(BNReportCollection)]:
result = _BNNewReportCollectionReference(reports)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewRepositoryManagerReference
_BNNewRepositoryManagerReference = core.BNNewRepositoryManagerReference
_BNNewRepositoryManagerReference.restype = ctypes.POINTER(BNRepositoryManager)
_BNNewRepositoryManagerReference.argtypes = [
ctypes.POINTER(BNRepositoryManager),
]
# noinspection PyPep8Naming
def BNNewRepositoryManagerReference(
r: ctypes.POINTER(BNRepositoryManager)
) -> Optional[ctypes.POINTER(BNRepositoryManager)]:
result = _BNNewRepositoryManagerReference(r)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewRepositoryReference
_BNNewRepositoryReference = core.BNNewRepositoryReference
_BNNewRepositoryReference.restype = ctypes.POINTER(BNRepository)
_BNNewRepositoryReference.argtypes = [
ctypes.POINTER(BNRepository),
]
# noinspection PyPep8Naming
def BNNewRepositoryReference(
r: ctypes.POINTER(BNRepository)
) -> Optional[ctypes.POINTER(BNRepository)]:
result = _BNNewRepositoryReference(r)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewSaveSettingsReference
_BNNewSaveSettingsReference = core.BNNewSaveSettingsReference
_BNNewSaveSettingsReference.restype = ctypes.POINTER(BNSaveSettings)
_BNNewSaveSettingsReference.argtypes = [
ctypes.POINTER(BNSaveSettings),
]
# noinspection PyPep8Naming
def BNNewSaveSettingsReference(
settings: ctypes.POINTER(BNSaveSettings)
) -> Optional[ctypes.POINTER(BNSaveSettings)]:
result = _BNNewSaveSettingsReference(settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewScriptingInstanceReference
_BNNewScriptingInstanceReference = core.BNNewScriptingInstanceReference
_BNNewScriptingInstanceReference.restype = ctypes.POINTER(BNScriptingInstance)
_BNNewScriptingInstanceReference.argtypes = [
ctypes.POINTER(BNScriptingInstance),
]
# noinspection PyPep8Naming
def BNNewScriptingInstanceReference(
instance: ctypes.POINTER(BNScriptingInstance)
) -> Optional[ctypes.POINTER(BNScriptingInstance)]:
result = _BNNewScriptingInstanceReference(instance)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewSectionReference
_BNNewSectionReference = core.BNNewSectionReference
_BNNewSectionReference.restype = ctypes.POINTER(BNSection)
_BNNewSectionReference.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNNewSectionReference(
section: ctypes.POINTER(BNSection)
) -> Optional[ctypes.POINTER(BNSection)]:
result = _BNNewSectionReference(section)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewSegmentReference
_BNNewSegmentReference = core.BNNewSegmentReference
_BNNewSegmentReference.restype = ctypes.POINTER(BNSegment)
_BNNewSegmentReference.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNNewSegmentReference(
seg: ctypes.POINTER(BNSegment)
) -> Optional[ctypes.POINTER(BNSegment)]:
result = _BNNewSegmentReference(seg)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewSettingsReference
_BNNewSettingsReference = core.BNNewSettingsReference
_BNNewSettingsReference.restype = ctypes.POINTER(BNSettings)
_BNNewSettingsReference.argtypes = [
ctypes.POINTER(BNSettings),
]
# noinspection PyPep8Naming
def BNNewSettingsReference(
settings: ctypes.POINTER(BNSettings)
) -> Optional[ctypes.POINTER(BNSettings)]:
result = _BNNewSettingsReference(settings)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewSnapshotReference
_BNNewSnapshotReference = core.BNNewSnapshotReference
_BNNewSnapshotReference.restype = ctypes.POINTER(BNSnapshot)
_BNNewSnapshotReference.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNNewSnapshotReference(
snapshot: ctypes.POINTER(BNSnapshot)
) -> Optional[ctypes.POINTER(BNSnapshot)]:
result = _BNNewSnapshotReference(snapshot)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewStructureReference
_BNNewStructureReference = core.BNNewStructureReference
_BNNewStructureReference.restype = ctypes.POINTER(BNStructure)
_BNNewStructureReference.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNNewStructureReference(
s: ctypes.POINTER(BNStructure)
) -> Optional[ctypes.POINTER(BNStructure)]:
result = _BNNewStructureReference(s)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewSymbolReference
_BNNewSymbolReference = core.BNNewSymbolReference
_BNNewSymbolReference.restype = ctypes.POINTER(BNSymbol)
_BNNewSymbolReference.argtypes = [
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNNewSymbolReference(
sym: ctypes.POINTER(BNSymbol)
) -> Optional[ctypes.POINTER(BNSymbol)]:
result = _BNNewSymbolReference(sym)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewTagReference
_BNNewTagReference = core.BNNewTagReference
_BNNewTagReference.restype = ctypes.POINTER(BNTag)
_BNNewTagReference.argtypes = [
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNNewTagReference(
tag: ctypes.POINTER(BNTag)
) -> Optional[ctypes.POINTER(BNTag)]:
result = _BNNewTagReference(tag)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewTagTypeReference
_BNNewTagTypeReference = core.BNNewTagTypeReference
_BNNewTagTypeReference.restype = ctypes.POINTER(BNTagType)
_BNNewTagTypeReference.argtypes = [
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNNewTagTypeReference(
tagType: ctypes.POINTER(BNTagType)
) -> Optional[ctypes.POINTER(BNTagType)]:
result = _BNNewTagTypeReference(tagType)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewTemporaryFileReference
_BNNewTemporaryFileReference = core.BNNewTemporaryFileReference
_BNNewTemporaryFileReference.restype = ctypes.POINTER(BNTemporaryFile)
_BNNewTemporaryFileReference.argtypes = [
ctypes.POINTER(BNTemporaryFile),
]
# noinspection PyPep8Naming
def BNNewTemporaryFileReference(
file: ctypes.POINTER(BNTemporaryFile)
) -> Optional[ctypes.POINTER(BNTemporaryFile)]:
result = _BNNewTemporaryFileReference(file)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewTypeArchiveReference
_BNNewTypeArchiveReference = core.BNNewTypeArchiveReference
_BNNewTypeArchiveReference.restype = ctypes.POINTER(BNTypeArchive)
_BNNewTypeArchiveReference.argtypes = [
ctypes.POINTER(BNTypeArchive),
]
# noinspection PyPep8Naming
def BNNewTypeArchiveReference(
archive: ctypes.POINTER(BNTypeArchive)
) -> Optional[ctypes.POINTER(BNTypeArchive)]:
result = _BNNewTypeArchiveReference(archive)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewTypeLibrary
_BNNewTypeLibrary = core.BNNewTypeLibrary
_BNNewTypeLibrary.restype = ctypes.POINTER(BNTypeLibrary)
_BNNewTypeLibrary.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNNewTypeLibrary(
arch: ctypes.POINTER(BNArchitecture),
name: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
result = _BNNewTypeLibrary(arch, cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewTypeLibraryReference
_BNNewTypeLibraryReference = core.BNNewTypeLibraryReference
_BNNewTypeLibraryReference.restype = ctypes.POINTER(BNTypeLibrary)
_BNNewTypeLibraryReference.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNNewTypeLibraryReference(
lib: ctypes.POINTER(BNTypeLibrary)
) -> Optional[ctypes.POINTER(BNTypeLibrary)]:
result = _BNNewTypeLibraryReference(lib)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewTypeReference
_BNNewTypeReference = core.BNNewTypeReference
_BNNewTypeReference.restype = ctypes.POINTER(BNType)
_BNNewTypeReference.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNNewTypeReference(
type: ctypes.POINTER(BNType)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNNewTypeReference(type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewUserReference
_BNNewUserReference = core.BNNewUserReference
_BNNewUserReference.restype = ctypes.POINTER(BNUser)
_BNNewUserReference.argtypes = [
ctypes.POINTER(BNUser),
]
# noinspection PyPep8Naming
def BNNewUserReference(
user: ctypes.POINTER(BNUser)
) -> Optional[ctypes.POINTER(BNUser)]:
result = _BNNewUserReference(user)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewViewReference
_BNNewViewReference = core.BNNewViewReference
_BNNewViewReference.restype = ctypes.POINTER(BNBinaryView)
_BNNewViewReference.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNNewViewReference(
view: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNNewViewReference(view)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewWebsocketClientReference
_BNNewWebsocketClientReference = core.BNNewWebsocketClientReference
_BNNewWebsocketClientReference.restype = ctypes.POINTER(BNWebsocketClient)
_BNNewWebsocketClientReference.argtypes = [
ctypes.POINTER(BNWebsocketClient),
]
# noinspection PyPep8Naming
def BNNewWebsocketClientReference(
client: ctypes.POINTER(BNWebsocketClient)
) -> Optional[ctypes.POINTER(BNWebsocketClient)]:
result = _BNNewWebsocketClientReference(client)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNewWorkflowReference
_BNNewWorkflowReference = core.BNNewWorkflowReference
_BNNewWorkflowReference.restype = ctypes.POINTER(BNWorkflow)
_BNNewWorkflowReference.argtypes = [
ctypes.POINTER(BNWorkflow),
]
# noinspection PyPep8Naming
def BNNewWorkflowReference(
workflow: ctypes.POINTER(BNWorkflow)
) -> Optional[ctypes.POINTER(BNWorkflow)]:
result = _BNNewWorkflowReference(workflow)
if not result:
return None
return result
# -------------------------------------------------------
# _BNNotifyDataInserted
_BNNotifyDataInserted = core.BNNotifyDataInserted
_BNNotifyDataInserted.restype = None
_BNNotifyDataInserted.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNNotifyDataInserted(
view: ctypes.POINTER(BNBinaryView),
offset: int,
len: int
) -> None:
return _BNNotifyDataInserted(view, offset, len)
# -------------------------------------------------------
# _BNNotifyDataRemoved
_BNNotifyDataRemoved = core.BNNotifyDataRemoved
_BNNotifyDataRemoved.restype = None
_BNNotifyDataRemoved.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNNotifyDataRemoved(
view: ctypes.POINTER(BNBinaryView),
offset: int,
len: int
) -> None:
return _BNNotifyDataRemoved(view, offset, len)
# -------------------------------------------------------
# _BNNotifyDataWritten
_BNNotifyDataWritten = core.BNNotifyDataWritten
_BNNotifyDataWritten.restype = None
_BNNotifyDataWritten.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNNotifyDataWritten(
view: ctypes.POINTER(BNBinaryView),
offset: int,
len: int
) -> None:
return _BNNotifyDataWritten(view, offset, len)
# -------------------------------------------------------
# _BNNotifyErrorForScriptingInstance
_BNNotifyErrorForScriptingInstance = core.BNNotifyErrorForScriptingInstance
_BNNotifyErrorForScriptingInstance.restype = None
_BNNotifyErrorForScriptingInstance.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNNotifyErrorForScriptingInstance(
instance: ctypes.POINTER(BNScriptingInstance),
text: Optional[str]
) -> None:
return _BNNotifyErrorForScriptingInstance(instance, cstr(text))
# -------------------------------------------------------
# _BNNotifyInputReadyStateForScriptingInstance
_BNNotifyInputReadyStateForScriptingInstance = core.BNNotifyInputReadyStateForScriptingInstance
_BNNotifyInputReadyStateForScriptingInstance.restype = None
_BNNotifyInputReadyStateForScriptingInstance.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ScriptingProviderInputReadyStateEnum,
]
# noinspection PyPep8Naming
def BNNotifyInputReadyStateForScriptingInstance(
instance: ctypes.POINTER(BNScriptingInstance),
state: ScriptingProviderInputReadyState
) -> None:
return _BNNotifyInputReadyStateForScriptingInstance(instance, state)
# -------------------------------------------------------
# _BNNotifyOutputForScriptingInstance
_BNNotifyOutputForScriptingInstance = core.BNNotifyOutputForScriptingInstance
_BNNotifyOutputForScriptingInstance.restype = None
_BNNotifyOutputForScriptingInstance.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNNotifyOutputForScriptingInstance(
instance: ctypes.POINTER(BNScriptingInstance),
text: Optional[str]
) -> None:
return _BNNotifyOutputForScriptingInstance(instance, cstr(text))
# -------------------------------------------------------
# _BNNotifyProgressForDownloadInstance
_BNNotifyProgressForDownloadInstance = core.BNNotifyProgressForDownloadInstance
_BNNotifyProgressForDownloadInstance.restype = ctypes.c_bool
_BNNotifyProgressForDownloadInstance.argtypes = [
ctypes.POINTER(BNDownloadInstance),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNNotifyProgressForDownloadInstance(
instance: ctypes.POINTER(BNDownloadInstance),
progress: int,
total: int
) -> bool:
return _BNNotifyProgressForDownloadInstance(instance, progress, total)
# -------------------------------------------------------
# _BNNotifyWarningForScriptingInstance
_BNNotifyWarningForScriptingInstance = core.BNNotifyWarningForScriptingInstance
_BNNotifyWarningForScriptingInstance.restype = None
_BNNotifyWarningForScriptingInstance.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNNotifyWarningForScriptingInstance(
instance: ctypes.POINTER(BNScriptingInstance),
text: Optional[str]
) -> None:
return _BNNotifyWarningForScriptingInstance(instance, cstr(text))
# -------------------------------------------------------
# _BNNotifyWebsocketClientConnect
_BNNotifyWebsocketClientConnect = core.BNNotifyWebsocketClientConnect
_BNNotifyWebsocketClientConnect.restype = ctypes.c_bool
_BNNotifyWebsocketClientConnect.argtypes = [
ctypes.POINTER(BNWebsocketClient),
]
# noinspection PyPep8Naming
def BNNotifyWebsocketClientConnect(
client: ctypes.POINTER(BNWebsocketClient)
) -> bool:
return _BNNotifyWebsocketClientConnect(client)
# -------------------------------------------------------
# _BNNotifyWebsocketClientDisconnect
_BNNotifyWebsocketClientDisconnect = core.BNNotifyWebsocketClientDisconnect
_BNNotifyWebsocketClientDisconnect.restype = None
_BNNotifyWebsocketClientDisconnect.argtypes = [
ctypes.POINTER(BNWebsocketClient),
]
# noinspection PyPep8Naming
def BNNotifyWebsocketClientDisconnect(
client: ctypes.POINTER(BNWebsocketClient)
) -> None:
return _BNNotifyWebsocketClientDisconnect(client)
# -------------------------------------------------------
# _BNNotifyWebsocketClientError
_BNNotifyWebsocketClientError = core.BNNotifyWebsocketClientError
_BNNotifyWebsocketClientError.restype = None
_BNNotifyWebsocketClientError.argtypes = [
ctypes.POINTER(BNWebsocketClient),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNNotifyWebsocketClientError(
client: ctypes.POINTER(BNWebsocketClient),
msg: Optional[str]
) -> None:
return _BNNotifyWebsocketClientError(client, cstr(msg))
# -------------------------------------------------------
# _BNNotifyWebsocketClientReadData
_BNNotifyWebsocketClientReadData = core.BNNotifyWebsocketClientReadData
_BNNotifyWebsocketClientReadData.restype = ctypes.c_bool
_BNNotifyWebsocketClientReadData.argtypes = [
ctypes.POINTER(BNWebsocketClient),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNNotifyWebsocketClientReadData(
client: ctypes.POINTER(BNWebsocketClient),
data: ctypes.POINTER(ctypes.c_ubyte),
len: int
) -> bool:
return _BNNotifyWebsocketClientReadData(client, data, len)
# -------------------------------------------------------
# _BNOpenDatabaseForConfiguration
_BNOpenDatabaseForConfiguration = core.BNOpenDatabaseForConfiguration
_BNOpenDatabaseForConfiguration.restype = ctypes.POINTER(BNBinaryView)
_BNOpenDatabaseForConfiguration.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNOpenDatabaseForConfiguration(
file: ctypes.POINTER(BNFileMetadata),
path: Optional[str]
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNOpenDatabaseForConfiguration(file, cstr(path))
if not result:
return None
return result
# -------------------------------------------------------
# _BNOpenExistingDatabase
_BNOpenExistingDatabase = core.BNOpenExistingDatabase
_BNOpenExistingDatabase.restype = ctypes.POINTER(BNBinaryView)
_BNOpenExistingDatabase.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNOpenExistingDatabase(
file: ctypes.POINTER(BNFileMetadata),
path: Optional[str]
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNOpenExistingDatabase(file, cstr(path))
if not result:
return None
return result
# -------------------------------------------------------
# _BNOpenExistingDatabaseWithProgress
_BNOpenExistingDatabaseWithProgress = core.BNOpenExistingDatabaseWithProgress
_BNOpenExistingDatabaseWithProgress.restype = ctypes.POINTER(BNBinaryView)
_BNOpenExistingDatabaseWithProgress.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNOpenExistingDatabaseWithProgress(
file: ctypes.POINTER(BNFileMetadata),
path: Optional[str],
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNOpenExistingDatabaseWithProgress(file, cstr(path), ctxt, progress)
if not result:
return None
return result
# -------------------------------------------------------
# _BNOpenProject
_BNOpenProject = core.BNOpenProject
_BNOpenProject.restype = ctypes.POINTER(BNProject)
_BNOpenProject.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNOpenProject(
path: Optional[str]
) -> Optional[ctypes.POINTER(BNProject)]:
result = _BNOpenProject(cstr(path))
if not result:
return None
return result
# -------------------------------------------------------
# _BNOpenTypeArchive
_BNOpenTypeArchive = core.BNOpenTypeArchive
_BNOpenTypeArchive.restype = ctypes.POINTER(BNTypeArchive)
_BNOpenTypeArchive.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNOpenTypeArchive(
path: Optional[str]
) -> Optional[ctypes.POINTER(BNTypeArchive)]:
result = _BNOpenTypeArchive(cstr(path))
if not result:
return None
return result
# -------------------------------------------------------
# _BNOpenUrl
_BNOpenUrl = core.BNOpenUrl
_BNOpenUrl.restype = ctypes.c_bool
_BNOpenUrl.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNOpenUrl(
url: Optional[str]
) -> bool:
return _BNOpenUrl(cstr(url))
# -------------------------------------------------------
# _BNParseBinaryViewOfType
_BNParseBinaryViewOfType = core.BNParseBinaryViewOfType
_BNParseBinaryViewOfType.restype = ctypes.POINTER(BNBinaryView)
_BNParseBinaryViewOfType.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNParseBinaryViewOfType(
type: ctypes.POINTER(BNBinaryViewType),
data: ctypes.POINTER(BNBinaryView)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNParseBinaryViewOfType(type, data)
if not result:
return None
return result
# -------------------------------------------------------
# _BNParseDebugInfo
_BNParseDebugInfo = core.BNParseDebugInfo
_BNParseDebugInfo.restype = ctypes.POINTER(BNDebugInfo)
_BNParseDebugInfo.argtypes = [
ctypes.POINTER(BNDebugInfoParser),
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDebugInfo),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNParseDebugInfo(
parser: ctypes.POINTER(BNDebugInfoParser),
view: ctypes.POINTER(BNBinaryView),
debugFile: ctypes.POINTER(BNBinaryView),
existingDebugInfo: ctypes.POINTER(BNDebugInfo),
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
progressCtxt: Optional[ctypes.c_void_p]
) -> Optional[ctypes.POINTER(BNDebugInfo)]:
result = _BNParseDebugInfo(parser, view, debugFile, existingDebugInfo, progress, progressCtxt)
if not result:
return None
return result
# -------------------------------------------------------
# _BNParseExpression
_BNParseExpression = core.BNParseExpression
_BNParseExpression.restype = ctypes.c_bool
_BNParseExpression.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNParseExpression(
view: ctypes.POINTER(BNBinaryView),
expression: Optional[str],
offset: ctypes.POINTER(ctypes.c_ulonglong),
here: int,
errorString: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNParseExpression(view, cstr(expression), offset, here, errorString)
# -------------------------------------------------------
# _BNParsePossibleValueSet
_BNParsePossibleValueSet = core.BNParsePossibleValueSet
_BNParsePossibleValueSet.restype = ctypes.c_bool
_BNParsePossibleValueSet.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
RegisterValueTypeEnum,
ctypes.POINTER(BNPossibleValueSet),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNParsePossibleValueSet(
view: ctypes.POINTER(BNBinaryView),
valueText: Optional[str],
state: RegisterValueType,
result: ctypes.POINTER(BNPossibleValueSet),
here: int,
errors: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNParsePossibleValueSet(view, cstr(valueText), state, result, here, errors)
# -------------------------------------------------------
# _BNParseTypeParserOptionsText
_BNParseTypeParserOptionsText = core.BNParseTypeParserOptionsText
_BNParseTypeParserOptionsText.restype = ctypes.POINTER(ctypes.c_char_p)
_BNParseTypeParserOptionsText.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNParseTypeParserOptionsText(
optionsText: Optional[str],
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNParseTypeParserOptionsText(cstr(optionsText), count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNParseTypeString
_BNParseTypeString = core.BNParseTypeString
_BNParseTypeString.restype = ctypes.c_bool
_BNParseTypeString.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedNameAndType),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(BNQualifiedNameList),
]
# noinspection PyPep8Naming
def BNParseTypeString(
view: ctypes.POINTER(BNBinaryView),
text: Optional[str],
result: ctypes.POINTER(BNQualifiedNameAndType),
errors: ctypes.POINTER(ctypes.c_char_p),
typesAllowRedefinition: ctypes.POINTER(BNQualifiedNameList)
) -> bool:
return _BNParseTypeString(view, cstr(text), result, errors, typesAllowRedefinition)
# -------------------------------------------------------
# _BNParseTypesFromSource
_BNParseTypesFromSource = core.BNParseTypesFromSource
_BNParseTypesFromSource.restype = ctypes.c_bool
_BNParseTypesFromSource.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(BNTypeParserResult),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNParseTypesFromSource(
platform: ctypes.POINTER(BNPlatform),
source: Optional[str],
fileName: Optional[str],
result: ctypes.POINTER(BNTypeParserResult),
errors: ctypes.POINTER(ctypes.c_char_p),
includeDirs: ctypes.POINTER(ctypes.c_char_p),
includeDirCount: int,
autoTypeSource: Optional[str]
) -> bool:
return _BNParseTypesFromSource(platform, cstr(source), cstr(fileName), result, errors, includeDirs, includeDirCount, cstr(autoTypeSource))
# -------------------------------------------------------
# _BNParseTypesFromSourceFile
_BNParseTypesFromSourceFile = core.BNParseTypesFromSourceFile
_BNParseTypesFromSourceFile.restype = ctypes.c_bool
_BNParseTypesFromSourceFile.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.c_char_p,
ctypes.POINTER(BNTypeParserResult),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNParseTypesFromSourceFile(
platform: ctypes.POINTER(BNPlatform),
fileName: Optional[str],
result: ctypes.POINTER(BNTypeParserResult),
errors: ctypes.POINTER(ctypes.c_char_p),
includeDirs: ctypes.POINTER(ctypes.c_char_p),
includeDirCount: int,
autoTypeSource: Optional[str]
) -> bool:
return _BNParseTypesFromSourceFile(platform, cstr(fileName), result, errors, includeDirs, includeDirCount, cstr(autoTypeSource))
# -------------------------------------------------------
# _BNParseTypesString
_BNParseTypesString = core.BNParseTypesString
_BNParseTypesString.restype = ctypes.c_bool
_BNParseTypesString.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeParserResult),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(BNQualifiedNameList),
]
# noinspection PyPep8Naming
def BNParseTypesString(
view: ctypes.POINTER(BNBinaryView),
text: Optional[str],
options: ctypes.POINTER(ctypes.c_char_p),
optionCount: int,
includeDirs: ctypes.POINTER(ctypes.c_char_p),
includeDirCount: int,
result: ctypes.POINTER(BNTypeParserResult),
errors: ctypes.POINTER(ctypes.c_char_p),
typesAllowRedefinition: ctypes.POINTER(BNQualifiedNameList)
) -> bool:
return _BNParseTypesString(view, cstr(text), options, optionCount, includeDirs, includeDirCount, result, errors, typesAllowRedefinition)
# -------------------------------------------------------
# _BNPathExists
_BNPathExists = core.BNPathExists
_BNPathExists.restype = ctypes.c_bool
_BNPathExists.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNPathExists(
path: Optional[str]
) -> bool:
return _BNPathExists(cstr(path))
# -------------------------------------------------------
# _BNPerformCustomRequest
_BNPerformCustomRequest = core.BNPerformCustomRequest
_BNPerformCustomRequest.restype = ctypes.c_int
_BNPerformCustomRequest.argtypes = [
ctypes.POINTER(BNDownloadInstance),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.POINTER(BNDownloadInstanceResponse)),
ctypes.POINTER(BNDownloadInstanceInputOutputCallbacks),
]
# noinspection PyPep8Naming
def BNPerformCustomRequest(
instance: ctypes.POINTER(BNDownloadInstance),
method: Optional[str],
url: Optional[str],
headerCount: int,
headerKeys: ctypes.POINTER(ctypes.c_char_p),
headerValues: ctypes.POINTER(ctypes.c_char_p),
response: ctypes.POINTER(ctypes.POINTER(BNDownloadInstanceResponse)),
callbacks: ctypes.POINTER(BNDownloadInstanceInputOutputCallbacks)
) -> int:
return _BNPerformCustomRequest(instance, cstr(method), cstr(url), headerCount, headerKeys, headerValues, response, callbacks)
# -------------------------------------------------------
# _BNPerformDownloadRequest
_BNPerformDownloadRequest = core.BNPerformDownloadRequest
_BNPerformDownloadRequest.restype = ctypes.c_int
_BNPerformDownloadRequest.argtypes = [
ctypes.POINTER(BNDownloadInstance),
ctypes.c_char_p,
ctypes.POINTER(BNDownloadInstanceOutputCallbacks),
]
# noinspection PyPep8Naming
def BNPerformDownloadRequest(
instance: ctypes.POINTER(BNDownloadInstance),
url: Optional[str],
callbacks: ctypes.POINTER(BNDownloadInstanceOutputCallbacks)
) -> int:
return _BNPerformDownloadRequest(instance, cstr(url), callbacks)
# -------------------------------------------------------
# _BNPerformSearch
_BNPerformSearch = core.BNPerformSearch
_BNPerformSearch.restype = ctypes.c_bool
_BNPerformSearch.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNPerformSearch(
query: Optional[str],
buffer: ctypes.POINTER(ctypes.c_ubyte),
size: int,
callback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
context: Optional[ctypes.c_void_p]
) -> bool:
return _BNPerformSearch(cstr(query), buffer, size, callback, context)
# -------------------------------------------------------
# _BNPluginAreDependenciesBeingInstalled
_BNPluginAreDependenciesBeingInstalled = core.BNPluginAreDependenciesBeingInstalled
_BNPluginAreDependenciesBeingInstalled.restype = ctypes.c_bool
_BNPluginAreDependenciesBeingInstalled.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginAreDependenciesBeingInstalled(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginAreDependenciesBeingInstalled(p)
# -------------------------------------------------------
# _BNPluginDisable
_BNPluginDisable = core.BNPluginDisable
_BNPluginDisable.restype = ctypes.c_bool
_BNPluginDisable.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginDisable(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginDisable(p)
# -------------------------------------------------------
# _BNPluginEnable
_BNPluginEnable = core.BNPluginEnable
_BNPluginEnable.restype = ctypes.c_bool
_BNPluginEnable.argtypes = [
ctypes.POINTER(BNRepoPlugin),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNPluginEnable(
p: ctypes.POINTER(BNRepoPlugin),
force: bool
) -> bool:
return _BNPluginEnable(p, force)
# -------------------------------------------------------
# _BNPluginGetApis
_BNPluginGetApis = core.BNPluginGetApis
_BNPluginGetApis.restype = ctypes.POINTER(ctypes.c_char_p)
_BNPluginGetApis.argtypes = [
ctypes.POINTER(BNRepoPlugin),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNPluginGetApis(
p: ctypes.POINTER(BNRepoPlugin),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNPluginGetApis(p, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNPluginGetAuthor
_BNPluginGetAuthor = core.BNPluginGetAuthor
_BNPluginGetAuthor.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetAuthor.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetAuthor(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetAuthor(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetAuthorUrl
_BNPluginGetAuthorUrl = core.BNPluginGetAuthorUrl
_BNPluginGetAuthorUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetAuthorUrl.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetAuthorUrl(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetAuthorUrl(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetCommit
_BNPluginGetCommit = core.BNPluginGetCommit
_BNPluginGetCommit.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetCommit.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetCommit(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetCommit(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetDependencies
_BNPluginGetDependencies = core.BNPluginGetDependencies
_BNPluginGetDependencies.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetDependencies.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetDependencies(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetDependencies(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetDescription
_BNPluginGetDescription = core.BNPluginGetDescription
_BNPluginGetDescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetDescription.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetDescription(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetDescription(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetInstallInstructions
_BNPluginGetInstallInstructions = core.BNPluginGetInstallInstructions
_BNPluginGetInstallInstructions.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetInstallInstructions.argtypes = [
ctypes.POINTER(BNRepoPlugin),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNPluginGetInstallInstructions(
p: ctypes.POINTER(BNRepoPlugin),
platform: Optional[str]
) -> Optional[Optional[str]]:
result = _BNPluginGetInstallInstructions(p, cstr(platform))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetLastUpdate
_BNPluginGetLastUpdate = core.BNPluginGetLastUpdate
_BNPluginGetLastUpdate.restype = ctypes.c_ulonglong
_BNPluginGetLastUpdate.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetLastUpdate(
p: ctypes.POINTER(BNRepoPlugin)
) -> int:
return _BNPluginGetLastUpdate(p)
# -------------------------------------------------------
# _BNPluginGetLicense
_BNPluginGetLicense = core.BNPluginGetLicense
_BNPluginGetLicense.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetLicense.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetLicense(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetLicense(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetLicenseText
_BNPluginGetLicenseText = core.BNPluginGetLicenseText
_BNPluginGetLicenseText.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetLicenseText.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetLicenseText(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetLicenseText(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetLongdescription
_BNPluginGetLongdescription = core.BNPluginGetLongdescription
_BNPluginGetLongdescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetLongdescription.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetLongdescription(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetLongdescription(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetMinimumVersion
_BNPluginGetMinimumVersion = core.BNPluginGetMinimumVersion
_BNPluginGetMinimumVersion.restype = ctypes.c_ulonglong
_BNPluginGetMinimumVersion.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetMinimumVersion(
p: ctypes.POINTER(BNRepoPlugin)
) -> int:
return _BNPluginGetMinimumVersion(p)
# -------------------------------------------------------
# _BNPluginGetName
_BNPluginGetName = core.BNPluginGetName
_BNPluginGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetName.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetName(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetName(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetPackageUrl
_BNPluginGetPackageUrl = core.BNPluginGetPackageUrl
_BNPluginGetPackageUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetPackageUrl.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetPackageUrl(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetPackageUrl(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetPath
_BNPluginGetPath = core.BNPluginGetPath
_BNPluginGetPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetPath.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetPath(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetPath(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetPlatforms
_BNPluginGetPlatforms = core.BNPluginGetPlatforms
_BNPluginGetPlatforms.restype = ctypes.POINTER(ctypes.c_char_p)
_BNPluginGetPlatforms.argtypes = [
ctypes.POINTER(BNRepoPlugin),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNPluginGetPlatforms(
p: ctypes.POINTER(BNRepoPlugin),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNPluginGetPlatforms(p, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNPluginGetPluginStatus
_BNPluginGetPluginStatus = core.BNPluginGetPluginStatus
_BNPluginGetPluginStatus.restype = PluginStatusEnum
_BNPluginGetPluginStatus.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetPluginStatus(
p: ctypes.POINTER(BNRepoPlugin)
) -> PluginStatus:
return _BNPluginGetPluginStatus(p)
# -------------------------------------------------------
# _BNPluginGetPluginTypes
_BNPluginGetPluginTypes = core.BNPluginGetPluginTypes
_BNPluginGetPluginTypes.restype = ctypes.POINTER(PluginTypeEnum)
_BNPluginGetPluginTypes.argtypes = [
ctypes.POINTER(BNRepoPlugin),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNPluginGetPluginTypes(
p: ctypes.POINTER(BNRepoPlugin),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(PluginTypeEnum)]:
result = _BNPluginGetPluginTypes(p, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNPluginGetProjectData
_BNPluginGetProjectData = core.BNPluginGetProjectData
_BNPluginGetProjectData.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetProjectData.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetProjectData(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetProjectData(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetProjectUrl
_BNPluginGetProjectUrl = core.BNPluginGetProjectUrl
_BNPluginGetProjectUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetProjectUrl.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetProjectUrl(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetProjectUrl(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetRepository
_BNPluginGetRepository = core.BNPluginGetRepository
_BNPluginGetRepository.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetRepository.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetRepository(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetRepository(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetSubdir
_BNPluginGetSubdir = core.BNPluginGetSubdir
_BNPluginGetSubdir.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetSubdir.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetSubdir(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetSubdir(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginGetVersion
_BNPluginGetVersion = core.BNPluginGetVersion
_BNPluginGetVersion.restype = ctypes.POINTER(ctypes.c_byte)
_BNPluginGetVersion.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginGetVersion(
p: ctypes.POINTER(BNRepoPlugin)
) -> Optional[Optional[str]]:
result = _BNPluginGetVersion(p)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPluginInstall
_BNPluginInstall = core.BNPluginInstall
_BNPluginInstall.restype = ctypes.c_bool
_BNPluginInstall.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginInstall(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginInstall(p)
# -------------------------------------------------------
# _BNPluginInstallDependencies
_BNPluginInstallDependencies = core.BNPluginInstallDependencies
_BNPluginInstallDependencies.restype = ctypes.c_bool
_BNPluginInstallDependencies.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginInstallDependencies(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginInstallDependencies(p)
# -------------------------------------------------------
# _BNPluginIsBeingDeleted
_BNPluginIsBeingDeleted = core.BNPluginIsBeingDeleted
_BNPluginIsBeingDeleted.restype = ctypes.c_bool
_BNPluginIsBeingDeleted.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginIsBeingDeleted(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginIsBeingDeleted(p)
# -------------------------------------------------------
# _BNPluginIsBeingUpdated
_BNPluginIsBeingUpdated = core.BNPluginIsBeingUpdated
_BNPluginIsBeingUpdated.restype = ctypes.c_bool
_BNPluginIsBeingUpdated.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginIsBeingUpdated(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginIsBeingUpdated(p)
# -------------------------------------------------------
# _BNPluginIsDeletePending
_BNPluginIsDeletePending = core.BNPluginIsDeletePending
_BNPluginIsDeletePending.restype = ctypes.c_bool
_BNPluginIsDeletePending.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginIsDeletePending(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginIsDeletePending(p)
# -------------------------------------------------------
# _BNPluginIsDisablePending
_BNPluginIsDisablePending = core.BNPluginIsDisablePending
_BNPluginIsDisablePending.restype = ctypes.c_bool
_BNPluginIsDisablePending.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginIsDisablePending(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginIsDisablePending(p)
# -------------------------------------------------------
# _BNPluginIsEnabled
_BNPluginIsEnabled = core.BNPluginIsEnabled
_BNPluginIsEnabled.restype = ctypes.c_bool
_BNPluginIsEnabled.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginIsEnabled(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginIsEnabled(p)
# -------------------------------------------------------
# _BNPluginIsInstalled
_BNPluginIsInstalled = core.BNPluginIsInstalled
_BNPluginIsInstalled.restype = ctypes.c_bool
_BNPluginIsInstalled.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginIsInstalled(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginIsInstalled(p)
# -------------------------------------------------------
# _BNPluginIsRunning
_BNPluginIsRunning = core.BNPluginIsRunning
_BNPluginIsRunning.restype = ctypes.c_bool
_BNPluginIsRunning.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginIsRunning(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginIsRunning(p)
# -------------------------------------------------------
# _BNPluginIsUpdateAvailable
_BNPluginIsUpdateAvailable = core.BNPluginIsUpdateAvailable
_BNPluginIsUpdateAvailable.restype = ctypes.c_bool
_BNPluginIsUpdateAvailable.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginIsUpdateAvailable(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginIsUpdateAvailable(p)
# -------------------------------------------------------
# _BNPluginIsUpdatePending
_BNPluginIsUpdatePending = core.BNPluginIsUpdatePending
_BNPluginIsUpdatePending.restype = ctypes.c_bool
_BNPluginIsUpdatePending.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginIsUpdatePending(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginIsUpdatePending(p)
# -------------------------------------------------------
# _BNPluginUninstall
_BNPluginUninstall = core.BNPluginUninstall
_BNPluginUninstall.restype = ctypes.c_bool
_BNPluginUninstall.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginUninstall(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginUninstall(p)
# -------------------------------------------------------
# _BNPluginUpdate
_BNPluginUpdate = core.BNPluginUpdate
_BNPluginUpdate.restype = ctypes.c_bool
_BNPluginUpdate.argtypes = [
ctypes.POINTER(BNRepoPlugin),
]
# noinspection PyPep8Naming
def BNPluginUpdate(
p: ctypes.POINTER(BNRepoPlugin)
) -> bool:
return _BNPluginUpdate(p)
# -------------------------------------------------------
# _BNPostProcessDisassemblyTextRendererLines
_BNPostProcessDisassemblyTextRendererLines = core.BNPostProcessDisassemblyTextRendererLines
_BNPostProcessDisassemblyTextRendererLines.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNPostProcessDisassemblyTextRendererLines.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(BNDisassemblyTextLine),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNPostProcessDisassemblyTextRendererLines(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
addr: int,
len: int,
inLines: ctypes.POINTER(BNDisassemblyTextLine),
inCount: int,
outCount: ctypes.POINTER(ctypes.c_ulonglong),
indentSpaces: Optional[str]
) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
result = _BNPostProcessDisassemblyTextRendererLines(renderer, addr, len, inLines, inCount, outCount, cstr(indentSpaces))
if not result:
return None
return result
# -------------------------------------------------------
# _BNPostWorkflowRequestForFunction
_BNPostWorkflowRequestForFunction = core.BNPostWorkflowRequestForFunction
_BNPostWorkflowRequestForFunction.restype = ctypes.POINTER(ctypes.c_byte)
_BNPostWorkflowRequestForFunction.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNPostWorkflowRequestForFunction(
func: ctypes.POINTER(BNFunction),
request: Optional[str]
) -> Optional[Optional[str]]:
result = _BNPostWorkflowRequestForFunction(func, cstr(request))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNPrepareToCopyLowLevelILBasicBlock
_BNPrepareToCopyLowLevelILBasicBlock = core.BNPrepareToCopyLowLevelILBasicBlock
_BNPrepareToCopyLowLevelILBasicBlock.restype = None
_BNPrepareToCopyLowLevelILBasicBlock.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNPrepareToCopyLowLevelILBasicBlock(
func: ctypes.POINTER(BNLowLevelILFunction),
block: ctypes.POINTER(BNBasicBlock)
) -> None:
return _BNPrepareToCopyLowLevelILBasicBlock(func, block)
# -------------------------------------------------------
# _BNPrepareToCopyLowLevelILFunction
_BNPrepareToCopyLowLevelILFunction = core.BNPrepareToCopyLowLevelILFunction
_BNPrepareToCopyLowLevelILFunction.restype = None
_BNPrepareToCopyLowLevelILFunction.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNPrepareToCopyLowLevelILFunction(
func: ctypes.POINTER(BNLowLevelILFunction),
src: ctypes.POINTER(BNLowLevelILFunction)
) -> None:
return _BNPrepareToCopyLowLevelILFunction(func, src)
# -------------------------------------------------------
# _BNPrepareToCopyMediumLevelILBasicBlock
_BNPrepareToCopyMediumLevelILBasicBlock = core.BNPrepareToCopyMediumLevelILBasicBlock
_BNPrepareToCopyMediumLevelILBasicBlock.restype = None
_BNPrepareToCopyMediumLevelILBasicBlock.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNPrepareToCopyMediumLevelILBasicBlock(
func: ctypes.POINTER(BNMediumLevelILFunction),
block: ctypes.POINTER(BNBasicBlock)
) -> None:
return _BNPrepareToCopyMediumLevelILBasicBlock(func, block)
# -------------------------------------------------------
# _BNPrepareToCopyMediumLevelILFunction
_BNPrepareToCopyMediumLevelILFunction = core.BNPrepareToCopyMediumLevelILFunction
_BNPrepareToCopyMediumLevelILFunction.restype = None
_BNPrepareToCopyMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNPrepareToCopyMediumLevelILFunction(
func: ctypes.POINTER(BNMediumLevelILFunction),
src: ctypes.POINTER(BNMediumLevelILFunction)
) -> None:
return _BNPrepareToCopyMediumLevelILFunction(func, src)
# -------------------------------------------------------
# _BNPreprocessSource
_BNPreprocessSource = core.BNPreprocessSource
_BNPreprocessSource.restype = ctypes.c_bool
_BNPreprocessSource.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNPreprocessSource(
source: Optional[str],
fileName: Optional[str],
output: ctypes.POINTER(ctypes.c_char_p),
errors: ctypes.POINTER(ctypes.c_char_p),
includeDirs: ctypes.POINTER(ctypes.c_char_p),
includeDirCount: int
) -> bool:
return _BNPreprocessSource(cstr(source), cstr(fileName), output, errors, includeDirs, includeDirCount)
# -------------------------------------------------------
# _BNProcessSymbolQueue
_BNProcessSymbolQueue = core.BNProcessSymbolQueue
_BNProcessSymbolQueue.restype = None
_BNProcessSymbolQueue.argtypes = [
ctypes.POINTER(BNSymbolQueue),
]
# noinspection PyPep8Naming
def BNProcessSymbolQueue(
queue: ctypes.POINTER(BNSymbolQueue)
) -> None:
return _BNProcessSymbolQueue(queue)
# -------------------------------------------------------
# _BNProjectBeginBulkOperation
_BNProjectBeginBulkOperation = core.BNProjectBeginBulkOperation
_BNProjectBeginBulkOperation.restype = None
_BNProjectBeginBulkOperation.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNProjectBeginBulkOperation(
project: ctypes.POINTER(BNProject)
) -> None:
return _BNProjectBeginBulkOperation(project)
# -------------------------------------------------------
# _BNProjectClose
_BNProjectClose = core.BNProjectClose
_BNProjectClose.restype = ctypes.c_bool
_BNProjectClose.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNProjectClose(
project: ctypes.POINTER(BNProject)
) -> bool:
return _BNProjectClose(project)
# -------------------------------------------------------
# _BNProjectCreateFile
_BNProjectCreateFile = core.BNProjectCreateFile
_BNProjectCreateFile.restype = ctypes.POINTER(BNProjectFile)
_BNProjectCreateFile.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNProjectCreateFile(
project: ctypes.POINTER(BNProject),
contents: ctypes.POINTER(ctypes.c_ubyte),
contentsSize: int,
folder: ctypes.POINTER(BNProjectFolder),
name: Optional[str],
description: Optional[str],
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNProjectFile)]:
result = _BNProjectCreateFile(project, contents, contentsSize, folder, cstr(name), cstr(description), ctxt, progress)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectCreateFileFromPath
_BNProjectCreateFileFromPath = core.BNProjectCreateFileFromPath
_BNProjectCreateFileFromPath.restype = ctypes.POINTER(BNProjectFile)
_BNProjectCreateFileFromPath.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNProjectCreateFileFromPath(
project: ctypes.POINTER(BNProject),
path: Optional[str],
folder: ctypes.POINTER(BNProjectFolder),
name: Optional[str],
description: Optional[str],
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNProjectFile)]:
result = _BNProjectCreateFileFromPath(project, cstr(path), folder, cstr(name), cstr(description), ctxt, progress)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectCreateFileFromPathUnsafe
_BNProjectCreateFileFromPathUnsafe = core.BNProjectCreateFileFromPathUnsafe
_BNProjectCreateFileFromPathUnsafe.restype = ctypes.POINTER(BNProjectFile)
_BNProjectCreateFileFromPathUnsafe.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_longlong,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNProjectCreateFileFromPathUnsafe(
project: ctypes.POINTER(BNProject),
path: Optional[str],
folder: ctypes.POINTER(BNProjectFolder),
name: Optional[str],
description: Optional[str],
id: Optional[str],
creationTimestamp: int,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNProjectFile)]:
result = _BNProjectCreateFileFromPathUnsafe(project, cstr(path), folder, cstr(name), cstr(description), cstr(id), creationTimestamp, ctxt, progress)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectCreateFileUnsafe
_BNProjectCreateFileUnsafe = core.BNProjectCreateFileUnsafe
_BNProjectCreateFileUnsafe.restype = ctypes.POINTER(BNProjectFile)
_BNProjectCreateFileUnsafe.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_longlong,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNProjectCreateFileUnsafe(
project: ctypes.POINTER(BNProject),
contents: ctypes.POINTER(ctypes.c_ubyte),
contentsSize: int,
folder: ctypes.POINTER(BNProjectFolder),
name: Optional[str],
description: Optional[str],
id: Optional[str],
creationTimestamp: int,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNProjectFile)]:
result = _BNProjectCreateFileUnsafe(project, contents, contentsSize, folder, cstr(name), cstr(description), cstr(id), creationTimestamp, ctxt, progress)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectCreateFolder
_BNProjectCreateFolder = core.BNProjectCreateFolder
_BNProjectCreateFolder.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectCreateFolder.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectCreateFolder(
project: ctypes.POINTER(BNProject),
parent: ctypes.POINTER(BNProjectFolder),
name: Optional[str],
description: Optional[str]
) -> Optional[ctypes.POINTER(BNProjectFolder)]:
result = _BNProjectCreateFolder(project, parent, cstr(name), cstr(description))
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectCreateFolderFromPath
_BNProjectCreateFolderFromPath = core.BNProjectCreateFolderFromPath
_BNProjectCreateFolderFromPath.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectCreateFolderFromPath.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNProjectCreateFolderFromPath(
project: ctypes.POINTER(BNProject),
path: Optional[str],
parent: ctypes.POINTER(BNProjectFolder),
description: Optional[str],
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNProjectFolder)]:
result = _BNProjectCreateFolderFromPath(project, cstr(path), parent, cstr(description), ctxt, progress)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectCreateFolderUnsafe
_BNProjectCreateFolderUnsafe = core.BNProjectCreateFolderUnsafe
_BNProjectCreateFolderUnsafe.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectCreateFolderUnsafe.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectCreateFolderUnsafe(
project: ctypes.POINTER(BNProject),
parent: ctypes.POINTER(BNProjectFolder),
name: Optional[str],
description: Optional[str],
id: Optional[str]
) -> Optional[ctypes.POINTER(BNProjectFolder)]:
result = _BNProjectCreateFolderUnsafe(project, parent, cstr(name), cstr(description), cstr(id))
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectDeleteFile
_BNProjectDeleteFile = core.BNProjectDeleteFile
_BNProjectDeleteFile.restype = ctypes.c_bool
_BNProjectDeleteFile.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectDeleteFile(
project: ctypes.POINTER(BNProject),
file: ctypes.POINTER(BNProjectFile)
) -> bool:
return _BNProjectDeleteFile(project, file)
# -------------------------------------------------------
# _BNProjectDeleteFolder
_BNProjectDeleteFolder = core.BNProjectDeleteFolder
_BNProjectDeleteFolder.restype = ctypes.c_bool
_BNProjectDeleteFolder.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(BNProjectFolder),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNProjectDeleteFolder(
project: ctypes.POINTER(BNProject),
folder: ctypes.POINTER(BNProjectFolder),
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> bool:
return _BNProjectDeleteFolder(project, folder, ctxt, progress)
# -------------------------------------------------------
# _BNProjectEndBulkOperation
_BNProjectEndBulkOperation = core.BNProjectEndBulkOperation
_BNProjectEndBulkOperation.restype = None
_BNProjectEndBulkOperation.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNProjectEndBulkOperation(
project: ctypes.POINTER(BNProject)
) -> None:
return _BNProjectEndBulkOperation(project)
# -------------------------------------------------------
# _BNProjectFileExistsOnDisk
_BNProjectFileExistsOnDisk = core.BNProjectFileExistsOnDisk
_BNProjectFileExistsOnDisk.restype = ctypes.c_bool
_BNProjectFileExistsOnDisk.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectFileExistsOnDisk(
file: ctypes.POINTER(BNProjectFile)
) -> bool:
return _BNProjectFileExistsOnDisk(file)
# -------------------------------------------------------
# _BNProjectFileExport
_BNProjectFileExport = core.BNProjectFileExport
_BNProjectFileExport.restype = ctypes.c_bool
_BNProjectFileExport.argtypes = [
ctypes.POINTER(BNProjectFile),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectFileExport(
file: ctypes.POINTER(BNProjectFile),
destination: Optional[str]
) -> bool:
return _BNProjectFileExport(file, cstr(destination))
# -------------------------------------------------------
# _BNProjectFileGetCreationTimestamp
_BNProjectFileGetCreationTimestamp = core.BNProjectFileGetCreationTimestamp
_BNProjectFileGetCreationTimestamp.restype = ctypes.c_longlong
_BNProjectFileGetCreationTimestamp.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectFileGetCreationTimestamp(
file: ctypes.POINTER(BNProjectFile)
) -> int:
return _BNProjectFileGetCreationTimestamp(file)
# -------------------------------------------------------
# _BNProjectFileGetDescription
_BNProjectFileGetDescription = core.BNProjectFileGetDescription
_BNProjectFileGetDescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFileGetDescription.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectFileGetDescription(
file: ctypes.POINTER(BNProjectFile)
) -> Optional[Optional[str]]:
result = _BNProjectFileGetDescription(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectFileGetFolder
_BNProjectFileGetFolder = core.BNProjectFileGetFolder
_BNProjectFileGetFolder.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectFileGetFolder.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectFileGetFolder(
file: ctypes.POINTER(BNProjectFile)
) -> Optional[ctypes.POINTER(BNProjectFolder)]:
result = _BNProjectFileGetFolder(file)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectFileGetId
_BNProjectFileGetId = core.BNProjectFileGetId
_BNProjectFileGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFileGetId.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectFileGetId(
file: ctypes.POINTER(BNProjectFile)
) -> Optional[Optional[str]]:
result = _BNProjectFileGetId(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectFileGetName
_BNProjectFileGetName = core.BNProjectFileGetName
_BNProjectFileGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFileGetName.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectFileGetName(
file: ctypes.POINTER(BNProjectFile)
) -> Optional[Optional[str]]:
result = _BNProjectFileGetName(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectFileGetPathOnDisk
_BNProjectFileGetPathOnDisk = core.BNProjectFileGetPathOnDisk
_BNProjectFileGetPathOnDisk.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFileGetPathOnDisk.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectFileGetPathOnDisk(
file: ctypes.POINTER(BNProjectFile)
) -> Optional[Optional[str]]:
result = _BNProjectFileGetPathOnDisk(file)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectFileGetProject
_BNProjectFileGetProject = core.BNProjectFileGetProject
_BNProjectFileGetProject.restype = ctypes.POINTER(BNProject)
_BNProjectFileGetProject.argtypes = [
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectFileGetProject(
file: ctypes.POINTER(BNProjectFile)
) -> Optional[ctypes.POINTER(BNProject)]:
result = _BNProjectFileGetProject(file)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectFileSetDescription
_BNProjectFileSetDescription = core.BNProjectFileSetDescription
_BNProjectFileSetDescription.restype = None
_BNProjectFileSetDescription.argtypes = [
ctypes.POINTER(BNProjectFile),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectFileSetDescription(
file: ctypes.POINTER(BNProjectFile),
description: Optional[str]
) -> None:
return _BNProjectFileSetDescription(file, cstr(description))
# -------------------------------------------------------
# _BNProjectFileSetFolder
_BNProjectFileSetFolder = core.BNProjectFileSetFolder
_BNProjectFileSetFolder.restype = None
_BNProjectFileSetFolder.argtypes = [
ctypes.POINTER(BNProjectFile),
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNProjectFileSetFolder(
file: ctypes.POINTER(BNProjectFile),
folder: ctypes.POINTER(BNProjectFolder)
) -> None:
return _BNProjectFileSetFolder(file, folder)
# -------------------------------------------------------
# _BNProjectFileSetName
_BNProjectFileSetName = core.BNProjectFileSetName
_BNProjectFileSetName.restype = None
_BNProjectFileSetName.argtypes = [
ctypes.POINTER(BNProjectFile),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectFileSetName(
file: ctypes.POINTER(BNProjectFile),
name: Optional[str]
) -> None:
return _BNProjectFileSetName(file, cstr(name))
# -------------------------------------------------------
# _BNProjectFolderExport
_BNProjectFolderExport = core.BNProjectFolderExport
_BNProjectFolderExport.restype = ctypes.c_bool
_BNProjectFolderExport.argtypes = [
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNProjectFolderExport(
folder: ctypes.POINTER(BNProjectFolder),
destination: Optional[str],
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> bool:
return _BNProjectFolderExport(folder, cstr(destination), ctxt, progress)
# -------------------------------------------------------
# _BNProjectFolderGetDescription
_BNProjectFolderGetDescription = core.BNProjectFolderGetDescription
_BNProjectFolderGetDescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFolderGetDescription.argtypes = [
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNProjectFolderGetDescription(
folder: ctypes.POINTER(BNProjectFolder)
) -> Optional[Optional[str]]:
result = _BNProjectFolderGetDescription(folder)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectFolderGetId
_BNProjectFolderGetId = core.BNProjectFolderGetId
_BNProjectFolderGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFolderGetId.argtypes = [
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNProjectFolderGetId(
folder: ctypes.POINTER(BNProjectFolder)
) -> Optional[Optional[str]]:
result = _BNProjectFolderGetId(folder)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectFolderGetName
_BNProjectFolderGetName = core.BNProjectFolderGetName
_BNProjectFolderGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectFolderGetName.argtypes = [
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNProjectFolderGetName(
folder: ctypes.POINTER(BNProjectFolder)
) -> Optional[Optional[str]]:
result = _BNProjectFolderGetName(folder)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectFolderGetParent
_BNProjectFolderGetParent = core.BNProjectFolderGetParent
_BNProjectFolderGetParent.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectFolderGetParent.argtypes = [
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNProjectFolderGetParent(
folder: ctypes.POINTER(BNProjectFolder)
) -> Optional[ctypes.POINTER(BNProjectFolder)]:
result = _BNProjectFolderGetParent(folder)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectFolderGetProject
_BNProjectFolderGetProject = core.BNProjectFolderGetProject
_BNProjectFolderGetProject.restype = ctypes.POINTER(BNProject)
_BNProjectFolderGetProject.argtypes = [
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNProjectFolderGetProject(
folder: ctypes.POINTER(BNProjectFolder)
) -> Optional[ctypes.POINTER(BNProject)]:
result = _BNProjectFolderGetProject(folder)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectFolderSetDescription
_BNProjectFolderSetDescription = core.BNProjectFolderSetDescription
_BNProjectFolderSetDescription.restype = None
_BNProjectFolderSetDescription.argtypes = [
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectFolderSetDescription(
folder: ctypes.POINTER(BNProjectFolder),
description: Optional[str]
) -> None:
return _BNProjectFolderSetDescription(folder, cstr(description))
# -------------------------------------------------------
# _BNProjectFolderSetName
_BNProjectFolderSetName = core.BNProjectFolderSetName
_BNProjectFolderSetName.restype = None
_BNProjectFolderSetName.argtypes = [
ctypes.POINTER(BNProjectFolder),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectFolderSetName(
folder: ctypes.POINTER(BNProjectFolder),
name: Optional[str]
) -> None:
return _BNProjectFolderSetName(folder, cstr(name))
# -------------------------------------------------------
# _BNProjectFolderSetParent
_BNProjectFolderSetParent = core.BNProjectFolderSetParent
_BNProjectFolderSetParent.restype = None
_BNProjectFolderSetParent.argtypes = [
ctypes.POINTER(BNProjectFolder),
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNProjectFolderSetParent(
folder: ctypes.POINTER(BNProjectFolder),
parent: ctypes.POINTER(BNProjectFolder)
) -> None:
return _BNProjectFolderSetParent(folder, parent)
# -------------------------------------------------------
# _BNProjectGetDescription
_BNProjectGetDescription = core.BNProjectGetDescription
_BNProjectGetDescription.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectGetDescription.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNProjectGetDescription(
project: ctypes.POINTER(BNProject)
) -> Optional[Optional[str]]:
result = _BNProjectGetDescription(project)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectGetFileById
_BNProjectGetFileById = core.BNProjectGetFileById
_BNProjectGetFileById.restype = ctypes.POINTER(BNProjectFile)
_BNProjectGetFileById.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectGetFileById(
project: ctypes.POINTER(BNProject),
id: Optional[str]
) -> Optional[ctypes.POINTER(BNProjectFile)]:
result = _BNProjectGetFileById(project, cstr(id))
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectGetFileByPathOnDisk
_BNProjectGetFileByPathOnDisk = core.BNProjectGetFileByPathOnDisk
_BNProjectGetFileByPathOnDisk.restype = ctypes.POINTER(BNProjectFile)
_BNProjectGetFileByPathOnDisk.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectGetFileByPathOnDisk(
project: ctypes.POINTER(BNProject),
path: Optional[str]
) -> Optional[ctypes.POINTER(BNProjectFile)]:
result = _BNProjectGetFileByPathOnDisk(project, cstr(path))
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectGetFiles
_BNProjectGetFiles = core.BNProjectGetFiles
_BNProjectGetFiles.restype = ctypes.POINTER(ctypes.POINTER(BNProjectFile))
_BNProjectGetFiles.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNProjectGetFiles(
project: ctypes.POINTER(BNProject),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNProjectFile))]:
result = _BNProjectGetFiles(project, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectGetFolderById
_BNProjectGetFolderById = core.BNProjectGetFolderById
_BNProjectGetFolderById.restype = ctypes.POINTER(BNProjectFolder)
_BNProjectGetFolderById.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectGetFolderById(
project: ctypes.POINTER(BNProject),
id: Optional[str]
) -> Optional[ctypes.POINTER(BNProjectFolder)]:
result = _BNProjectGetFolderById(project, cstr(id))
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectGetFolders
_BNProjectGetFolders = core.BNProjectGetFolders
_BNProjectGetFolders.restype = ctypes.POINTER(ctypes.POINTER(BNProjectFolder))
_BNProjectGetFolders.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNProjectGetFolders(
project: ctypes.POINTER(BNProject),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNProjectFolder))]:
result = _BNProjectGetFolders(project, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectGetId
_BNProjectGetId = core.BNProjectGetId
_BNProjectGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectGetId.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNProjectGetId(
project: ctypes.POINTER(BNProject)
) -> Optional[Optional[str]]:
result = _BNProjectGetId(project)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectGetName
_BNProjectGetName = core.BNProjectGetName
_BNProjectGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectGetName.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNProjectGetName(
project: ctypes.POINTER(BNProject)
) -> Optional[Optional[str]]:
result = _BNProjectGetName(project)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectGetPath
_BNProjectGetPath = core.BNProjectGetPath
_BNProjectGetPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNProjectGetPath.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNProjectGetPath(
project: ctypes.POINTER(BNProject)
) -> Optional[Optional[str]]:
result = _BNProjectGetPath(project)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNProjectIsOpen
_BNProjectIsOpen = core.BNProjectIsOpen
_BNProjectIsOpen.restype = ctypes.c_bool
_BNProjectIsOpen.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNProjectIsOpen(
project: ctypes.POINTER(BNProject)
) -> bool:
return _BNProjectIsOpen(project)
# -------------------------------------------------------
# _BNProjectOpen
_BNProjectOpen = core.BNProjectOpen
_BNProjectOpen.restype = ctypes.c_bool
_BNProjectOpen.argtypes = [
ctypes.POINTER(BNProject),
]
# noinspection PyPep8Naming
def BNProjectOpen(
project: ctypes.POINTER(BNProject)
) -> bool:
return _BNProjectOpen(project)
# -------------------------------------------------------
# _BNProjectPushFile
_BNProjectPushFile = core.BNProjectPushFile
_BNProjectPushFile.restype = None
_BNProjectPushFile.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNProjectPushFile(
project: ctypes.POINTER(BNProject),
file: ctypes.POINTER(BNProjectFile)
) -> None:
return _BNProjectPushFile(project, file)
# -------------------------------------------------------
# _BNProjectPushFolder
_BNProjectPushFolder = core.BNProjectPushFolder
_BNProjectPushFolder.restype = None
_BNProjectPushFolder.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(BNProjectFolder),
]
# noinspection PyPep8Naming
def BNProjectPushFolder(
project: ctypes.POINTER(BNProject),
folder: ctypes.POINTER(BNProjectFolder)
) -> None:
return _BNProjectPushFolder(project, folder)
# -------------------------------------------------------
# _BNProjectQueryMetadata
_BNProjectQueryMetadata = core.BNProjectQueryMetadata
_BNProjectQueryMetadata.restype = ctypes.POINTER(BNMetadata)
_BNProjectQueryMetadata.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectQueryMetadata(
project: ctypes.POINTER(BNProject),
key: Optional[str]
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNProjectQueryMetadata(project, cstr(key))
if not result:
return None
return result
# -------------------------------------------------------
# _BNProjectRemoveMetadata
_BNProjectRemoveMetadata = core.BNProjectRemoveMetadata
_BNProjectRemoveMetadata.restype = None
_BNProjectRemoveMetadata.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectRemoveMetadata(
project: ctypes.POINTER(BNProject),
key: Optional[str]
) -> None:
return _BNProjectRemoveMetadata(project, cstr(key))
# -------------------------------------------------------
# _BNProjectSetDescription
_BNProjectSetDescription = core.BNProjectSetDescription
_BNProjectSetDescription.restype = None
_BNProjectSetDescription.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectSetDescription(
project: ctypes.POINTER(BNProject),
description: Optional[str]
) -> None:
return _BNProjectSetDescription(project, cstr(description))
# -------------------------------------------------------
# _BNProjectSetName
_BNProjectSetName = core.BNProjectSetName
_BNProjectSetName.restype = None
_BNProjectSetName.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNProjectSetName(
project: ctypes.POINTER(BNProject),
name: Optional[str]
) -> None:
return _BNProjectSetName(project, cstr(name))
# -------------------------------------------------------
# _BNProjectStoreMetadata
_BNProjectStoreMetadata = core.BNProjectStoreMetadata
_BNProjectStoreMetadata.restype = ctypes.c_bool
_BNProjectStoreMetadata.argtypes = [
ctypes.POINTER(BNProject),
ctypes.c_char_p,
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNProjectStoreMetadata(
project: ctypes.POINTER(BNProject),
key: Optional[str],
value: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNProjectStoreMetadata(project, cstr(key), value)
# -------------------------------------------------------
# _BNRangeContainsRelocation
_BNRangeContainsRelocation = core.BNRangeContainsRelocation
_BNRangeContainsRelocation.restype = ctypes.c_bool
_BNRangeContainsRelocation.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRangeContainsRelocation(
view: ctypes.POINTER(BNBinaryView),
addr: int,
size: int
) -> bool:
return _BNRangeContainsRelocation(view, addr, size)
# -------------------------------------------------------
# _BNRead16
_BNRead16 = core.BNRead16
_BNRead16.restype = ctypes.c_bool
_BNRead16.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_ushort),
]
# noinspection PyPep8Naming
def BNRead16(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_ushort)
) -> bool:
return _BNRead16(stream, result)
# -------------------------------------------------------
# _BNRead32
_BNRead32 = core.BNRead32
_BNRead32.restype = ctypes.c_bool
_BNRead32.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_uint),
]
# noinspection PyPep8Naming
def BNRead32(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_uint)
) -> bool:
return _BNRead32(stream, result)
# -------------------------------------------------------
# _BNRead64
_BNRead64 = core.BNRead64
_BNRead64.restype = ctypes.c_bool
_BNRead64.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNRead64(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNRead64(stream, result)
# -------------------------------------------------------
# _BNRead8
_BNRead8 = core.BNRead8
_BNRead8.restype = ctypes.c_bool
_BNRead8.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_ubyte),
]
# noinspection PyPep8Naming
def BNRead8(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_ubyte)
) -> bool:
return _BNRead8(stream, result)
# -------------------------------------------------------
# _BNReadBE16
_BNReadBE16 = core.BNReadBE16
_BNReadBE16.restype = ctypes.c_bool
_BNReadBE16.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_ushort),
]
# noinspection PyPep8Naming
def BNReadBE16(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_ushort)
) -> bool:
return _BNReadBE16(stream, result)
# -------------------------------------------------------
# _BNReadBE32
_BNReadBE32 = core.BNReadBE32
_BNReadBE32.restype = ctypes.c_bool
_BNReadBE32.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_uint),
]
# noinspection PyPep8Naming
def BNReadBE32(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_uint)
) -> bool:
return _BNReadBE32(stream, result)
# -------------------------------------------------------
# _BNReadBE64
_BNReadBE64 = core.BNReadBE64
_BNReadBE64.restype = ctypes.c_bool
_BNReadBE64.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNReadBE64(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNReadBE64(stream, result)
# -------------------------------------------------------
# _BNReadData
_BNReadData = core.BNReadData
_BNReadData.restype = ctypes.c_bool
_BNReadData.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.c_void_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReadData(
stream: ctypes.POINTER(BNBinaryReader),
dest: Optional[ctypes.c_void_p],
len: int
) -> bool:
return _BNReadData(stream, dest, len)
# -------------------------------------------------------
# _BNReadDataForDownloadInstance
_BNReadDataForDownloadInstance = core.BNReadDataForDownloadInstance
_BNReadDataForDownloadInstance.restype = ctypes.c_longlong
_BNReadDataForDownloadInstance.argtypes = [
ctypes.POINTER(BNDownloadInstance),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReadDataForDownloadInstance(
instance: ctypes.POINTER(BNDownloadInstance),
data: ctypes.POINTER(ctypes.c_ubyte),
len: int
) -> int:
return _BNReadDataForDownloadInstance(instance, data, len)
# -------------------------------------------------------
# _BNReadDatabaseAnalysisCache
_BNReadDatabaseAnalysisCache = core.BNReadDatabaseAnalysisCache
_BNReadDatabaseAnalysisCache.restype = ctypes.POINTER(BNKeyValueStore)
_BNReadDatabaseAnalysisCache.argtypes = [
ctypes.POINTER(BNDatabase),
]
# noinspection PyPep8Naming
def BNReadDatabaseAnalysisCache(
database: ctypes.POINTER(BNDatabase)
) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
result = _BNReadDatabaseAnalysisCache(database)
if not result:
return None
return result
# -------------------------------------------------------
# _BNReadDatabaseGlobal
_BNReadDatabaseGlobal = core.BNReadDatabaseGlobal
_BNReadDatabaseGlobal.restype = ctypes.POINTER(ctypes.c_byte)
_BNReadDatabaseGlobal.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNReadDatabaseGlobal(
database: ctypes.POINTER(BNDatabase),
key: Optional[str]
) -> Optional[Optional[str]]:
result = _BNReadDatabaseGlobal(database, cstr(key))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNReadDatabaseGlobalData
_BNReadDatabaseGlobalData = core.BNReadDatabaseGlobalData
_BNReadDatabaseGlobalData.restype = ctypes.POINTER(BNDataBuffer)
_BNReadDatabaseGlobalData.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNReadDatabaseGlobalData(
database: ctypes.POINTER(BNDatabase),
key: Optional[str]
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNReadDatabaseGlobalData(database, cstr(key))
if not result:
return None
return result
# -------------------------------------------------------
# _BNReadLE16
_BNReadLE16 = core.BNReadLE16
_BNReadLE16.restype = ctypes.c_bool
_BNReadLE16.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_ushort),
]
# noinspection PyPep8Naming
def BNReadLE16(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_ushort)
) -> bool:
return _BNReadLE16(stream, result)
# -------------------------------------------------------
# _BNReadLE32
_BNReadLE32 = core.BNReadLE32
_BNReadLE32.restype = ctypes.c_bool
_BNReadLE32.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_uint),
]
# noinspection PyPep8Naming
def BNReadLE32(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_uint)
) -> bool:
return _BNReadLE32(stream, result)
# -------------------------------------------------------
# _BNReadLE64
_BNReadLE64 = core.BNReadLE64
_BNReadLE64.restype = ctypes.c_bool
_BNReadLE64.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNReadLE64(
stream: ctypes.POINTER(BNBinaryReader),
result: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNReadLE64(stream, result)
# -------------------------------------------------------
# _BNReadSnapshotData
_BNReadSnapshotData = core.BNReadSnapshotData
_BNReadSnapshotData.restype = ctypes.POINTER(BNKeyValueStore)
_BNReadSnapshotData.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNReadSnapshotData(
snapshot: ctypes.POINTER(BNSnapshot)
) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
result = _BNReadSnapshotData(snapshot)
if not result:
return None
return result
# -------------------------------------------------------
# _BNReadSnapshotDataWithProgress
_BNReadSnapshotDataWithProgress = core.BNReadSnapshotDataWithProgress
_BNReadSnapshotDataWithProgress.restype = ctypes.POINTER(BNKeyValueStore)
_BNReadSnapshotDataWithProgress.argtypes = [
ctypes.POINTER(BNSnapshot),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNReadSnapshotDataWithProgress(
snapshot: ctypes.POINTER(BNSnapshot),
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNKeyValueStore)]:
result = _BNReadSnapshotDataWithProgress(snapshot, ctxt, progress)
if not result:
return None
return result
# -------------------------------------------------------
# _BNReadViewBuffer
_BNReadViewBuffer = core.BNReadViewBuffer
_BNReadViewBuffer.restype = ctypes.POINTER(BNDataBuffer)
_BNReadViewBuffer.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReadViewBuffer(
view: ctypes.POINTER(BNBinaryView),
offset: int,
len: int
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNReadViewBuffer(view, offset, len)
if not result:
return None
return result
# -------------------------------------------------------
# _BNReadViewData
_BNReadViewData = core.BNReadViewData
_BNReadViewData.restype = ctypes.c_ulonglong
_BNReadViewData.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_void_p,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReadViewData(
view: ctypes.POINTER(BNBinaryView),
dest: Optional[ctypes.c_void_p],
offset: int,
len: int
) -> int:
return _BNReadViewData(view, dest, offset, len)
# -------------------------------------------------------
# _BNReanalyzeAllFunctions
_BNReanalyzeAllFunctions = core.BNReanalyzeAllFunctions
_BNReanalyzeAllFunctions.restype = None
_BNReanalyzeAllFunctions.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNReanalyzeAllFunctions(
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNReanalyzeAllFunctions(view)
# -------------------------------------------------------
# _BNReanalyzeFunction
_BNReanalyzeFunction = core.BNReanalyzeFunction
_BNReanalyzeFunction.restype = None
_BNReanalyzeFunction.argtypes = [
ctypes.POINTER(BNFunction),
FunctionUpdateTypeEnum,
]
# noinspection PyPep8Naming
def BNReanalyzeFunction(
func: ctypes.POINTER(BNFunction),
type: FunctionUpdateType
) -> None:
return _BNReanalyzeFunction(func, type)
# -------------------------------------------------------
# _BNRebase
_BNRebase = core.BNRebase
_BNRebase.restype = ctypes.c_bool
_BNRebase.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRebase(
data: ctypes.POINTER(BNBinaryView),
address: int
) -> bool:
return _BNRebase(data, address)
# -------------------------------------------------------
# _BNRebaseWithProgress
_BNRebaseWithProgress = core.BNRebaseWithProgress
_BNRebaseWithProgress.restype = ctypes.c_bool
_BNRebaseWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNRebaseWithProgress(
data: ctypes.POINTER(BNBinaryView),
address: int,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> bool:
return _BNRebaseWithProgress(data, address, ctxt, progress)
# -------------------------------------------------------
# _BNRecognizePlatformForViewType
_BNRecognizePlatformForViewType = core.BNRecognizePlatformForViewType
_BNRecognizePlatformForViewType.restype = ctypes.POINTER(BNPlatform)
_BNRecognizePlatformForViewType.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.c_ulonglong,
EndiannessEnum,
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNRecognizePlatformForViewType(
type: ctypes.POINTER(BNBinaryViewType),
id: int,
endian: Endianness,
view: ctypes.POINTER(BNBinaryView),
metadata: ctypes.POINTER(BNMetadata)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNRecognizePlatformForViewType(type, id, endian, view, metadata)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRedo
_BNRedo = core.BNRedo
_BNRedo.restype = ctypes.c_bool
_BNRedo.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNRedo(
file: ctypes.POINTER(BNFileMetadata)
) -> bool:
return _BNRedo(file)
# -------------------------------------------------------
# _BNRegisterArchitecture
_BNRegisterArchitecture = core.BNRegisterArchitecture
_BNRegisterArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNRegisterArchitecture.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNCustomArchitecture),
]
# noinspection PyPep8Naming
def BNRegisterArchitecture(
name: Optional[str],
arch: ctypes.POINTER(BNCustomArchitecture)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNRegisterArchitecture(cstr(name), arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterArchitectureExtension
_BNRegisterArchitectureExtension = core.BNRegisterArchitectureExtension
_BNRegisterArchitectureExtension.restype = ctypes.POINTER(BNArchitecture)
_BNRegisterArchitectureExtension.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNCustomArchitecture),
]
# noinspection PyPep8Naming
def BNRegisterArchitectureExtension(
name: Optional[str],
base: ctypes.POINTER(BNArchitecture),
arch: ctypes.POINTER(BNCustomArchitecture)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNRegisterArchitectureExtension(cstr(name), base, arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterArchitectureForViewType
_BNRegisterArchitectureForViewType = core.BNRegisterArchitectureForViewType
_BNRegisterArchitectureForViewType.restype = None
_BNRegisterArchitectureForViewType.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.c_uint,
EndiannessEnum,
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNRegisterArchitectureForViewType(
type: ctypes.POINTER(BNBinaryViewType),
id: int,
endian: Endianness,
arch: ctypes.POINTER(BNArchitecture)
) -> None:
return _BNRegisterArchitectureForViewType(type, id, endian, arch)
# -------------------------------------------------------
# _BNRegisterArchitectureFunctionRecognizer
_BNRegisterArchitectureFunctionRecognizer = core.BNRegisterArchitectureFunctionRecognizer
_BNRegisterArchitectureFunctionRecognizer.restype = None
_BNRegisterArchitectureFunctionRecognizer.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNFunctionRecognizer),
]
# noinspection PyPep8Naming
def BNRegisterArchitectureFunctionRecognizer(
arch: ctypes.POINTER(BNArchitecture),
rec: ctypes.POINTER(BNFunctionRecognizer)
) -> None:
return _BNRegisterArchitectureFunctionRecognizer(arch, rec)
# -------------------------------------------------------
# _BNRegisterArchitectureHook
_BNRegisterArchitectureHook = core.BNRegisterArchitectureHook
_BNRegisterArchitectureHook.restype = ctypes.POINTER(BNArchitecture)
_BNRegisterArchitectureHook.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNCustomArchitecture),
]
# noinspection PyPep8Naming
def BNRegisterArchitectureHook(
base: ctypes.POINTER(BNArchitecture),
arch: ctypes.POINTER(BNCustomArchitecture)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNRegisterArchitectureHook(base, arch)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterBinaryViewEvent
_BNRegisterBinaryViewEvent = core.BNRegisterBinaryViewEvent
_BNRegisterBinaryViewEvent.restype = None
_BNRegisterBinaryViewEvent.argtypes = [
BinaryViewEventTypeEnum,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterBinaryViewEvent(
type: BinaryViewEventType,
callback: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
ctx: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterBinaryViewEvent(type, callback, ctx)
# -------------------------------------------------------
# _BNRegisterBinaryViewType
_BNRegisterBinaryViewType = core.BNRegisterBinaryViewType
_BNRegisterBinaryViewType.restype = ctypes.POINTER(BNBinaryViewType)
_BNRegisterBinaryViewType.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(BNCustomBinaryViewType),
]
# noinspection PyPep8Naming
def BNRegisterBinaryViewType(
name: Optional[str],
longName: Optional[str],
type: ctypes.POINTER(BNCustomBinaryViewType)
) -> Optional[ctypes.POINTER(BNBinaryViewType)]:
result = _BNRegisterBinaryViewType(cstr(name), cstr(longName), type)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterCallingConvention
_BNRegisterCallingConvention = core.BNRegisterCallingConvention
_BNRegisterCallingConvention.restype = None
_BNRegisterCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNRegisterCallingConvention(
arch: ctypes.POINTER(BNArchitecture),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNRegisterCallingConvention(arch, cc)
# -------------------------------------------------------
# _BNRegisterDataNotification
_BNRegisterDataNotification = core.BNRegisterDataNotification
_BNRegisterDataNotification.restype = None
_BNRegisterDataNotification.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNBinaryDataNotification),
]
# noinspection PyPep8Naming
def BNRegisterDataNotification(
view: ctypes.POINTER(BNBinaryView),
notify: ctypes.POINTER(BNBinaryDataNotification)
) -> None:
return _BNRegisterDataNotification(view, notify)
# -------------------------------------------------------
# _BNRegisterDebugInfoParser
_BNRegisterDebugInfoParser = core.BNRegisterDebugInfoParser
_BNRegisterDebugInfoParser.restype = ctypes.POINTER(BNDebugInfoParser)
_BNRegisterDebugInfoParser.argtypes = [
ctypes.c_char_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDebugInfo), ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNBinaryView), ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterDebugInfoParser(
name: Optional[str],
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
parseInfo: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNDebugInfo), ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNBinaryView), ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p),
context: Optional[ctypes.c_void_p]
) -> Optional[ctypes.POINTER(BNDebugInfoParser)]:
result = _BNRegisterDebugInfoParser(cstr(name), isValid, parseInfo, context)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterDefaultPlatformForViewType
_BNRegisterDefaultPlatformForViewType = core.BNRegisterDefaultPlatformForViewType
_BNRegisterDefaultPlatformForViewType.restype = None
_BNRegisterDefaultPlatformForViewType.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNRegisterDefaultPlatformForViewType(
type: ctypes.POINTER(BNBinaryViewType),
arch: ctypes.POINTER(BNArchitecture),
platform: ctypes.POINTER(BNPlatform)
) -> None:
return _BNRegisterDefaultPlatformForViewType(type, arch, platform)
# -------------------------------------------------------
# _BNRegisterDownloadProvider
_BNRegisterDownloadProvider = core.BNRegisterDownloadProvider
_BNRegisterDownloadProvider.restype = ctypes.POINTER(BNDownloadProvider)
_BNRegisterDownloadProvider.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNDownloadProviderCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterDownloadProvider(
name: Optional[str],
callbacks: ctypes.POINTER(BNDownloadProviderCallbacks)
) -> Optional[ctypes.POINTER(BNDownloadProvider)]:
result = _BNRegisterDownloadProvider(cstr(name), callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterEnterpriseServerNotification
_BNRegisterEnterpriseServerNotification = core.BNRegisterEnterpriseServerNotification
_BNRegisterEnterpriseServerNotification.restype = None
_BNRegisterEnterpriseServerNotification.argtypes = [
ctypes.POINTER(BNEnterpriseServerCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterEnterpriseServerNotification(
notify: ctypes.POINTER(BNEnterpriseServerCallbacks)
) -> None:
return _BNRegisterEnterpriseServerNotification(notify)
# -------------------------------------------------------
# _BNRegisterGenericDataRenderer
_BNRegisterGenericDataRenderer = core.BNRegisterGenericDataRenderer
_BNRegisterGenericDataRenderer.restype = None
_BNRegisterGenericDataRenderer.argtypes = [
ctypes.POINTER(BNDataRendererContainer),
ctypes.POINTER(BNDataRenderer),
]
# noinspection PyPep8Naming
def BNRegisterGenericDataRenderer(
container: ctypes.POINTER(BNDataRendererContainer),
renderer: ctypes.POINTER(BNDataRenderer)
) -> None:
return _BNRegisterGenericDataRenderer(container, renderer)
# -------------------------------------------------------
# _BNRegisterGlobalFunctionRecognizer
_BNRegisterGlobalFunctionRecognizer = core.BNRegisterGlobalFunctionRecognizer
_BNRegisterGlobalFunctionRecognizer.restype = None
_BNRegisterGlobalFunctionRecognizer.argtypes = [
ctypes.POINTER(BNFunctionRecognizer),
]
# noinspection PyPep8Naming
def BNRegisterGlobalFunctionRecognizer(
rec: ctypes.POINTER(BNFunctionRecognizer)
) -> None:
return _BNRegisterGlobalFunctionRecognizer(rec)
# -------------------------------------------------------
# _BNRegisterInteractionHandler
_BNRegisterInteractionHandler = core.BNRegisterInteractionHandler
_BNRegisterInteractionHandler.restype = None
_BNRegisterInteractionHandler.argtypes = [
ctypes.POINTER(BNInteractionHandlerCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterInteractionHandler(
callbacks: ctypes.POINTER(BNInteractionHandlerCallbacks)
) -> None:
return _BNRegisterInteractionHandler(callbacks)
# -------------------------------------------------------
# _BNRegisterLogListener
_BNRegisterLogListener = core.BNRegisterLogListener
_BNRegisterLogListener.restype = None
_BNRegisterLogListener.argtypes = [
ctypes.POINTER(BNLogListener),
]
# noinspection PyPep8Naming
def BNRegisterLogListener(
listener: ctypes.POINTER(BNLogListener)
) -> None:
return _BNRegisterLogListener(listener)
# -------------------------------------------------------
# _BNRegisterMainThread
_BNRegisterMainThread = core.BNRegisterMainThread
_BNRegisterMainThread.restype = None
_BNRegisterMainThread.argtypes = [
ctypes.POINTER(BNMainThreadCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterMainThread(
callbacks: ctypes.POINTER(BNMainThreadCallbacks)
) -> None:
return _BNRegisterMainThread(callbacks)
# -------------------------------------------------------
# _BNRegisterObjectDestructionCallbacks
_BNRegisterObjectDestructionCallbacks = core.BNRegisterObjectDestructionCallbacks
_BNRegisterObjectDestructionCallbacks.restype = None
_BNRegisterObjectDestructionCallbacks.argtypes = [
ctypes.POINTER(BNObjectDestructionCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterObjectDestructionCallbacks(
callbacks: ctypes.POINTER(BNObjectDestructionCallbacks)
) -> None:
return _BNRegisterObjectDestructionCallbacks(callbacks)
# -------------------------------------------------------
# _BNRegisterObjectRefDebugTrace
_BNRegisterObjectRefDebugTrace = core.BNRegisterObjectRefDebugTrace
_BNRegisterObjectRefDebugTrace.restype = ctypes.c_void_p
_BNRegisterObjectRefDebugTrace.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRegisterObjectRefDebugTrace(
typeName: Optional[str]
) -> Optional[Optional[ctypes.c_void_p]]:
result = _BNRegisterObjectRefDebugTrace(cstr(typeName))
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterPlatform
_BNRegisterPlatform = core.BNRegisterPlatform
_BNRegisterPlatform.restype = None
_BNRegisterPlatform.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNRegisterPlatform(
os: Optional[str],
platform: ctypes.POINTER(BNPlatform)
) -> None:
return _BNRegisterPlatform(cstr(os), platform)
# -------------------------------------------------------
# _BNRegisterPlatformCallingConvention
_BNRegisterPlatformCallingConvention = core.BNRegisterPlatformCallingConvention
_BNRegisterPlatformCallingConvention.restype = None
_BNRegisterPlatformCallingConvention.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNRegisterPlatformCallingConvention(
platform: ctypes.POINTER(BNPlatform),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNRegisterPlatformCallingConvention(platform, cc)
# -------------------------------------------------------
# _BNRegisterPlatformCdeclCallingConvention
_BNRegisterPlatformCdeclCallingConvention = core.BNRegisterPlatformCdeclCallingConvention
_BNRegisterPlatformCdeclCallingConvention.restype = None
_BNRegisterPlatformCdeclCallingConvention.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNRegisterPlatformCdeclCallingConvention(
platform: ctypes.POINTER(BNPlatform),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNRegisterPlatformCdeclCallingConvention(platform, cc)
# -------------------------------------------------------
# _BNRegisterPlatformDefaultCallingConvention
_BNRegisterPlatformDefaultCallingConvention = core.BNRegisterPlatformDefaultCallingConvention
_BNRegisterPlatformDefaultCallingConvention.restype = None
_BNRegisterPlatformDefaultCallingConvention.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNRegisterPlatformDefaultCallingConvention(
platform: ctypes.POINTER(BNPlatform),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNRegisterPlatformDefaultCallingConvention(platform, cc)
# -------------------------------------------------------
# _BNRegisterPlatformFastcallCallingConvention
_BNRegisterPlatformFastcallCallingConvention = core.BNRegisterPlatformFastcallCallingConvention
_BNRegisterPlatformFastcallCallingConvention.restype = None
_BNRegisterPlatformFastcallCallingConvention.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNRegisterPlatformFastcallCallingConvention(
platform: ctypes.POINTER(BNPlatform),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNRegisterPlatformFastcallCallingConvention(platform, cc)
# -------------------------------------------------------
# _BNRegisterPlatformForViewType
_BNRegisterPlatformForViewType = core.BNRegisterPlatformForViewType
_BNRegisterPlatformForViewType.restype = None
_BNRegisterPlatformForViewType.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.c_uint,
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNRegisterPlatformForViewType(
type: ctypes.POINTER(BNBinaryViewType),
id: int,
arch: ctypes.POINTER(BNArchitecture),
platform: ctypes.POINTER(BNPlatform)
) -> None:
return _BNRegisterPlatformForViewType(type, id, arch, platform)
# -------------------------------------------------------
# _BNRegisterPlatformRecognizerForViewType
_BNRegisterPlatformRecognizerForViewType = core.BNRegisterPlatformRecognizerForViewType
_BNRegisterPlatformRecognizerForViewType.restype = None
_BNRegisterPlatformRecognizerForViewType.argtypes = [
ctypes.POINTER(BNBinaryViewType),
ctypes.c_ulonglong,
EndiannessEnum,
ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMetadata)),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPlatformRecognizerForViewType(
type: ctypes.POINTER(BNBinaryViewType),
id: int,
endian: Endianness,
callback: ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMetadata)),
ctx: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPlatformRecognizerForViewType(type, id, endian, callback, ctx)
# -------------------------------------------------------
# _BNRegisterPlatformStdcallCallingConvention
_BNRegisterPlatformStdcallCallingConvention = core.BNRegisterPlatformStdcallCallingConvention
_BNRegisterPlatformStdcallCallingConvention.restype = None
_BNRegisterPlatformStdcallCallingConvention.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNRegisterPlatformStdcallCallingConvention(
platform: ctypes.POINTER(BNPlatform),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNRegisterPlatformStdcallCallingConvention(platform, cc)
# -------------------------------------------------------
# _BNRegisterPlatformTypes
_BNRegisterPlatformTypes = core.BNRegisterPlatformTypes
_BNRegisterPlatformTypes.restype = None
_BNRegisterPlatformTypes.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNRegisterPlatformTypes(
view: ctypes.POINTER(BNBinaryView),
platform: ctypes.POINTER(BNPlatform)
) -> None:
return _BNRegisterPlatformTypes(view, platform)
# -------------------------------------------------------
# _BNRegisterPluginCommand
_BNRegisterPluginCommand = core.BNRegisterPluginCommand
_BNRegisterPluginCommand.restype = None
_BNRegisterPluginCommand.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommand(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView)),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommand(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterPluginCommandForAddress
_BNRegisterPluginCommandForAddress = core.BNRegisterPluginCommandForAddress
_BNRegisterPluginCommandForAddress.restype = None
_BNRegisterPluginCommandForAddress.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommandForAddress(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommandForAddress(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterPluginCommandForFunction
_BNRegisterPluginCommandForFunction = core.BNRegisterPluginCommandForFunction
_BNRegisterPluginCommandForFunction.restype = None
_BNRegisterPluginCommandForFunction.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction)),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction)),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommandForFunction(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction)),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNFunction)),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommandForFunction(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterPluginCommandForHighLevelILFunction
_BNRegisterPluginCommandForHighLevelILFunction = core.BNRegisterPluginCommandForHighLevelILFunction
_BNRegisterPluginCommandForHighLevelILFunction.restype = None
_BNRegisterPluginCommandForHighLevelILFunction.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction)),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction)),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommandForHighLevelILFunction(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction)),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction)),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommandForHighLevelILFunction(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterPluginCommandForHighLevelILInstruction
_BNRegisterPluginCommandForHighLevelILInstruction = core.BNRegisterPluginCommandForHighLevelILInstruction
_BNRegisterPluginCommandForHighLevelILInstruction.restype = None
_BNRegisterPluginCommandForHighLevelILInstruction.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommandForHighLevelILInstruction(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNHighLevelILFunction), ctypes.c_ulonglong),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommandForHighLevelILInstruction(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterPluginCommandForLowLevelILFunction
_BNRegisterPluginCommandForLowLevelILFunction = core.BNRegisterPluginCommandForLowLevelILFunction
_BNRegisterPluginCommandForLowLevelILFunction.restype = None
_BNRegisterPluginCommandForLowLevelILFunction.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction)),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction)),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommandForLowLevelILFunction(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction)),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction)),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommandForLowLevelILFunction(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterPluginCommandForLowLevelILInstruction
_BNRegisterPluginCommandForLowLevelILInstruction = core.BNRegisterPluginCommandForLowLevelILInstruction
_BNRegisterPluginCommandForLowLevelILInstruction.restype = None
_BNRegisterPluginCommandForLowLevelILInstruction.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommandForLowLevelILInstruction(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNLowLevelILFunction), ctypes.c_ulonglong),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommandForLowLevelILInstruction(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterPluginCommandForMediumLevelILFunction
_BNRegisterPluginCommandForMediumLevelILFunction = core.BNRegisterPluginCommandForMediumLevelILFunction
_BNRegisterPluginCommandForMediumLevelILFunction.restype = None
_BNRegisterPluginCommandForMediumLevelILFunction.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction)),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction)),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommandForMediumLevelILFunction(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction)),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction)),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommandForMediumLevelILFunction(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterPluginCommandForMediumLevelILInstruction
_BNRegisterPluginCommandForMediumLevelILInstruction = core.BNRegisterPluginCommandForMediumLevelILInstruction
_BNRegisterPluginCommandForMediumLevelILInstruction.restype = None
_BNRegisterPluginCommandForMediumLevelILInstruction.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommandForMediumLevelILInstruction(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.POINTER(BNMediumLevelILFunction), ctypes.c_ulonglong),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommandForMediumLevelILInstruction(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterPluginCommandForRange
_BNRegisterPluginCommandForRange = core.BNRegisterPluginCommandForRange
_BNRegisterPluginCommandForRange.restype = None
_BNRegisterPluginCommandForRange.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRegisterPluginCommandForRange(
name: Optional[str],
description: Optional[str],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong),
isValid: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.POINTER(BNBinaryView), ctypes.c_ulonglong, ctypes.c_ulonglong),
context: Optional[ctypes.c_void_p]
) -> None:
return _BNRegisterPluginCommandForRange(cstr(name), cstr(description), action, isValid, context)
# -------------------------------------------------------
# _BNRegisterProjectNotification
_BNRegisterProjectNotification = core.BNRegisterProjectNotification
_BNRegisterProjectNotification.restype = None
_BNRegisterProjectNotification.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(BNProjectNotification),
]
# noinspection PyPep8Naming
def BNRegisterProjectNotification(
project: ctypes.POINTER(BNProject),
notify: ctypes.POINTER(BNProjectNotification)
) -> None:
return _BNRegisterProjectNotification(project, notify)
# -------------------------------------------------------
# _BNRegisterScriptingInstanceOutputListener
_BNRegisterScriptingInstanceOutputListener = core.BNRegisterScriptingInstanceOutputListener
_BNRegisterScriptingInstanceOutputListener.restype = None
_BNRegisterScriptingInstanceOutputListener.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.POINTER(BNScriptingOutputListener),
]
# noinspection PyPep8Naming
def BNRegisterScriptingInstanceOutputListener(
instance: ctypes.POINTER(BNScriptingInstance),
callbacks: ctypes.POINTER(BNScriptingOutputListener)
) -> None:
return _BNRegisterScriptingInstanceOutputListener(instance, callbacks)
# -------------------------------------------------------
# _BNRegisterScriptingProvider
_BNRegisterScriptingProvider = core.BNRegisterScriptingProvider
_BNRegisterScriptingProvider.restype = ctypes.POINTER(BNScriptingProvider)
_BNRegisterScriptingProvider.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(BNScriptingProviderCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterScriptingProvider(
name: Optional[str],
apiName: Optional[str],
callbacks: ctypes.POINTER(BNScriptingProviderCallbacks)
) -> Optional[ctypes.POINTER(BNScriptingProvider)]:
result = _BNRegisterScriptingProvider(cstr(name), cstr(apiName), callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterSecretsProvider
_BNRegisterSecretsProvider = core.BNRegisterSecretsProvider
_BNRegisterSecretsProvider.restype = ctypes.POINTER(BNSecretsProvider)
_BNRegisterSecretsProvider.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNSecretsProviderCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterSecretsProvider(
name: Optional[str],
callbacks: ctypes.POINTER(BNSecretsProviderCallbacks)
) -> Optional[ctypes.POINTER(BNSecretsProvider)]:
result = _BNRegisterSecretsProvider(cstr(name), callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterTransformType
_BNRegisterTransformType = core.BNRegisterTransformType
_BNRegisterTransformType.restype = ctypes.POINTER(BNTransform)
_BNRegisterTransformType.argtypes = [
TransformTypeEnum,
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(BNCustomTransform),
]
# noinspection PyPep8Naming
def BNRegisterTransformType(
type: TransformType,
name: Optional[str],
longName: Optional[str],
group: Optional[str],
xform: ctypes.POINTER(BNCustomTransform)
) -> Optional[ctypes.POINTER(BNTransform)]:
result = _BNRegisterTransformType(type, cstr(name), cstr(longName), cstr(group), xform)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterTypeArchiveNotification
_BNRegisterTypeArchiveNotification = core.BNRegisterTypeArchiveNotification
_BNRegisterTypeArchiveNotification.restype = None
_BNRegisterTypeArchiveNotification.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.POINTER(BNTypeArchiveNotification),
]
# noinspection PyPep8Naming
def BNRegisterTypeArchiveNotification(
archive: ctypes.POINTER(BNTypeArchive),
notification: ctypes.POINTER(BNTypeArchiveNotification)
) -> None:
return _BNRegisterTypeArchiveNotification(archive, notification)
# -------------------------------------------------------
# _BNRegisterTypeParser
_BNRegisterTypeParser = core.BNRegisterTypeParser
_BNRegisterTypeParser.restype = ctypes.POINTER(BNTypeParser)
_BNRegisterTypeParser.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNTypeParserCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterTypeParser(
name: Optional[str],
callbacks: ctypes.POINTER(BNTypeParserCallbacks)
) -> Optional[ctypes.POINTER(BNTypeParser)]:
result = _BNRegisterTypeParser(cstr(name), callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterTypePrinter
_BNRegisterTypePrinter = core.BNRegisterTypePrinter
_BNRegisterTypePrinter.restype = ctypes.POINTER(BNTypePrinter)
_BNRegisterTypePrinter.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNTypePrinterCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterTypePrinter(
name: Optional[str],
callbacks: ctypes.POINTER(BNTypePrinterCallbacks)
) -> Optional[ctypes.POINTER(BNTypePrinter)]:
result = _BNRegisterTypePrinter(cstr(name), callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterTypeSpecificDataRenderer
_BNRegisterTypeSpecificDataRenderer = core.BNRegisterTypeSpecificDataRenderer
_BNRegisterTypeSpecificDataRenderer.restype = None
_BNRegisterTypeSpecificDataRenderer.argtypes = [
ctypes.POINTER(BNDataRendererContainer),
ctypes.POINTER(BNDataRenderer),
]
# noinspection PyPep8Naming
def BNRegisterTypeSpecificDataRenderer(
container: ctypes.POINTER(BNDataRendererContainer),
renderer: ctypes.POINTER(BNDataRenderer)
) -> None:
return _BNRegisterTypeSpecificDataRenderer(container, renderer)
# -------------------------------------------------------
# _BNRegisterWebsocketProvider
_BNRegisterWebsocketProvider = core.BNRegisterWebsocketProvider
_BNRegisterWebsocketProvider.restype = ctypes.POINTER(BNWebsocketProvider)
_BNRegisterWebsocketProvider.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNWebsocketProviderCallbacks),
]
# noinspection PyPep8Naming
def BNRegisterWebsocketProvider(
name: Optional[str],
callbacks: ctypes.POINTER(BNWebsocketProviderCallbacks)
) -> Optional[ctypes.POINTER(BNWebsocketProvider)]:
result = _BNRegisterWebsocketProvider(cstr(name), callbacks)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRegisterWorkflow
_BNRegisterWorkflow = core.BNRegisterWorkflow
_BNRegisterWorkflow.restype = ctypes.c_bool
_BNRegisterWorkflow.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRegisterWorkflow(
workflow: ctypes.POINTER(BNWorkflow),
configuration: Optional[str]
) -> bool:
return _BNRegisterWorkflow(workflow, cstr(configuration))
# -------------------------------------------------------
# _BNReleaseAdvancedFunctionAnalysisData
_BNReleaseAdvancedFunctionAnalysisData = core.BNReleaseAdvancedFunctionAnalysisData
_BNReleaseAdvancedFunctionAnalysisData.restype = None
_BNReleaseAdvancedFunctionAnalysisData.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNReleaseAdvancedFunctionAnalysisData(
func: ctypes.POINTER(BNFunction)
) -> None:
return _BNReleaseAdvancedFunctionAnalysisData(func)
# -------------------------------------------------------
# _BNReleaseAdvancedFunctionAnalysisDataMultiple
_BNReleaseAdvancedFunctionAnalysisDataMultiple = core.BNReleaseAdvancedFunctionAnalysisDataMultiple
_BNReleaseAdvancedFunctionAnalysisDataMultiple.restype = None
_BNReleaseAdvancedFunctionAnalysisDataMultiple.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReleaseAdvancedFunctionAnalysisDataMultiple(
func: ctypes.POINTER(BNFunction),
count: int
) -> None:
return _BNReleaseAdvancedFunctionAnalysisDataMultiple(func, count)
# -------------------------------------------------------
# _BNReleaseEnterpriseServerLicense
_BNReleaseEnterpriseServerLicense = core.BNReleaseEnterpriseServerLicense
_BNReleaseEnterpriseServerLicense.restype = ctypes.c_bool
_BNReleaseEnterpriseServerLicense.argtypes = [
]
# noinspection PyPep8Naming
def BNReleaseEnterpriseServerLicense(
) -> bool:
return _BNReleaseEnterpriseServerLicense()
# -------------------------------------------------------
# _BNRelocationGetArchitecture
_BNRelocationGetArchitecture = core.BNRelocationGetArchitecture
_BNRelocationGetArchitecture.restype = ctypes.POINTER(BNArchitecture)
_BNRelocationGetArchitecture.argtypes = [
ctypes.POINTER(BNRelocation),
]
# noinspection PyPep8Naming
def BNRelocationGetArchitecture(
reloc: ctypes.POINTER(BNRelocation)
) -> Optional[ctypes.POINTER(BNArchitecture)]:
result = _BNRelocationGetArchitecture(reloc)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRelocationGetInfo
_BNRelocationGetInfo = core.BNRelocationGetInfo
_BNRelocationGetInfo.restype = BNRelocationInfo
_BNRelocationGetInfo.argtypes = [
ctypes.POINTER(BNRelocation),
]
# noinspection PyPep8Naming
def BNRelocationGetInfo(
reloc: ctypes.POINTER(BNRelocation)
) -> BNRelocationInfo:
return _BNRelocationGetInfo(reloc)
# -------------------------------------------------------
# _BNRelocationGetReloc
_BNRelocationGetReloc = core.BNRelocationGetReloc
_BNRelocationGetReloc.restype = ctypes.c_ulonglong
_BNRelocationGetReloc.argtypes = [
ctypes.POINTER(BNRelocation),
]
# noinspection PyPep8Naming
def BNRelocationGetReloc(
reloc: ctypes.POINTER(BNRelocation)
) -> int:
return _BNRelocationGetReloc(reloc)
# -------------------------------------------------------
# _BNRelocationGetSymbol
_BNRelocationGetSymbol = core.BNRelocationGetSymbol
_BNRelocationGetSymbol.restype = ctypes.POINTER(BNSymbol)
_BNRelocationGetSymbol.argtypes = [
ctypes.POINTER(BNRelocation),
]
# noinspection PyPep8Naming
def BNRelocationGetSymbol(
reloc: ctypes.POINTER(BNRelocation)
) -> Optional[ctypes.POINTER(BNSymbol)]:
result = _BNRelocationGetSymbol(reloc)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRelocationGetTarget
_BNRelocationGetTarget = core.BNRelocationGetTarget
_BNRelocationGetTarget.restype = ctypes.c_ulonglong
_BNRelocationGetTarget.argtypes = [
ctypes.POINTER(BNRelocation),
]
# noinspection PyPep8Naming
def BNRelocationGetTarget(
reloc: ctypes.POINTER(BNRelocation)
) -> int:
return _BNRelocationGetTarget(reloc)
# -------------------------------------------------------
# _BNRelocationHandlerApplyRelocation
_BNRelocationHandlerApplyRelocation = core.BNRelocationHandlerApplyRelocation
_BNRelocationHandlerApplyRelocation.restype = ctypes.c_bool
_BNRelocationHandlerApplyRelocation.argtypes = [
ctypes.POINTER(BNRelocationHandler),
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNRelocation),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRelocationHandlerApplyRelocation(
handler: ctypes.POINTER(BNRelocationHandler),
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
reloc: ctypes.POINTER(BNRelocation),
dest: ctypes.POINTER(ctypes.c_ubyte),
len: int
) -> bool:
return _BNRelocationHandlerApplyRelocation(handler, view, arch, reloc, dest, len)
# -------------------------------------------------------
# _BNRelocationHandlerDefaultApplyRelocation
_BNRelocationHandlerDefaultApplyRelocation = core.BNRelocationHandlerDefaultApplyRelocation
_BNRelocationHandlerDefaultApplyRelocation.restype = ctypes.c_bool
_BNRelocationHandlerDefaultApplyRelocation.argtypes = [
ctypes.POINTER(BNRelocationHandler),
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNRelocation),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRelocationHandlerDefaultApplyRelocation(
handler: ctypes.POINTER(BNRelocationHandler),
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
reloc: ctypes.POINTER(BNRelocation),
dest: ctypes.POINTER(ctypes.c_ubyte),
len: int
) -> bool:
return _BNRelocationHandlerDefaultApplyRelocation(handler, view, arch, reloc, dest, len)
# -------------------------------------------------------
# _BNRelocationHandlerGetOperandForExternalRelocation
_BNRelocationHandlerGetOperandForExternalRelocation = core.BNRelocationHandlerGetOperandForExternalRelocation
_BNRelocationHandlerGetOperandForExternalRelocation.restype = ctypes.c_ulonglong
_BNRelocationHandlerGetOperandForExternalRelocation.argtypes = [
ctypes.POINTER(BNRelocationHandler),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(BNLowLevelILFunction),
ctypes.POINTER(BNRelocation),
]
# noinspection PyPep8Naming
def BNRelocationHandlerGetOperandForExternalRelocation(
handler: ctypes.POINTER(BNRelocationHandler),
data: ctypes.POINTER(ctypes.c_ubyte),
addr: int,
length: int,
il: ctypes.POINTER(BNLowLevelILFunction),
relocation: ctypes.POINTER(BNRelocation)
) -> int:
return _BNRelocationHandlerGetOperandForExternalRelocation(handler, data, addr, length, il, relocation)
# -------------------------------------------------------
# _BNRelocationHandlerGetRelocationInfo
_BNRelocationHandlerGetRelocationInfo = core.BNRelocationHandlerGetRelocationInfo
_BNRelocationHandlerGetRelocationInfo.restype = ctypes.c_bool
_BNRelocationHandlerGetRelocationInfo.argtypes = [
ctypes.POINTER(BNRelocationHandler),
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNRelocationInfo),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRelocationHandlerGetRelocationInfo(
handler: ctypes.POINTER(BNRelocationHandler),
data: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
info: ctypes.POINTER(BNRelocationInfo),
infoCount: int
) -> bool:
return _BNRelocationHandlerGetRelocationInfo(handler, data, arch, info, infoCount)
# -------------------------------------------------------
# _BNRemoveAnalysisFunction
_BNRemoveAnalysisFunction = core.BNRemoveAnalysisFunction
_BNRemoveAnalysisFunction.restype = None
_BNRemoveAnalysisFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNFunction),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNRemoveAnalysisFunction(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNFunction),
updateRefs: bool
) -> None:
return _BNRemoveAnalysisFunction(view, func, updateRefs)
# -------------------------------------------------------
# _BNRemoveAutoAddressTag
_BNRemoveAutoAddressTag = core.BNRemoveAutoAddressTag
_BNRemoveAutoAddressTag.restype = None
_BNRemoveAutoAddressTag.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNRemoveAutoAddressTag(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNRemoveAutoAddressTag(func, arch, addr, tag)
# -------------------------------------------------------
# _BNRemoveAutoAddressTagsOfType
_BNRemoveAutoAddressTagsOfType = core.BNRemoveAutoAddressTagsOfType
_BNRemoveAutoAddressTagsOfType.restype = None
_BNRemoveAutoAddressTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNRemoveAutoAddressTagsOfType(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
tagType: ctypes.POINTER(BNTagType)
) -> None:
return _BNRemoveAutoAddressTagsOfType(func, arch, addr, tagType)
# -------------------------------------------------------
# _BNRemoveAutoDataTag
_BNRemoveAutoDataTag = core.BNRemoveAutoDataTag
_BNRemoveAutoDataTag.restype = None
_BNRemoveAutoDataTag.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNRemoveAutoDataTag(
view: ctypes.POINTER(BNBinaryView),
addr: int,
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNRemoveAutoDataTag(view, addr, tag)
# -------------------------------------------------------
# _BNRemoveAutoDataTagsOfType
_BNRemoveAutoDataTagsOfType = core.BNRemoveAutoDataTagsOfType
_BNRemoveAutoDataTagsOfType.restype = None
_BNRemoveAutoDataTagsOfType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNRemoveAutoDataTagsOfType(
view: ctypes.POINTER(BNBinaryView),
addr: int,
tagType: ctypes.POINTER(BNTagType)
) -> None:
return _BNRemoveAutoDataTagsOfType(view, addr, tagType)
# -------------------------------------------------------
# _BNRemoveAutoFunctionTag
_BNRemoveAutoFunctionTag = core.BNRemoveAutoFunctionTag
_BNRemoveAutoFunctionTag.restype = None
_BNRemoveAutoFunctionTag.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNRemoveAutoFunctionTag(
func: ctypes.POINTER(BNFunction),
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNRemoveAutoFunctionTag(func, tag)
# -------------------------------------------------------
# _BNRemoveAutoFunctionTagsOfType
_BNRemoveAutoFunctionTagsOfType = core.BNRemoveAutoFunctionTagsOfType
_BNRemoveAutoFunctionTagsOfType.restype = None
_BNRemoveAutoFunctionTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNRemoveAutoFunctionTagsOfType(
func: ctypes.POINTER(BNFunction),
tagType: ctypes.POINTER(BNTagType)
) -> None:
return _BNRemoveAutoFunctionTagsOfType(func, tagType)
# -------------------------------------------------------
# _BNRemoveAutoSection
_BNRemoveAutoSection = core.BNRemoveAutoSection
_BNRemoveAutoSection.restype = None
_BNRemoveAutoSection.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRemoveAutoSection(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> None:
return _BNRemoveAutoSection(view, cstr(name))
# -------------------------------------------------------
# _BNRemoveAutoSegment
_BNRemoveAutoSegment = core.BNRemoveAutoSegment
_BNRemoveAutoSegment.restype = None
_BNRemoveAutoSegment.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveAutoSegment(
view: ctypes.POINTER(BNBinaryView),
start: int,
length: int
) -> None:
return _BNRemoveAutoSegment(view, start, length)
# -------------------------------------------------------
# _BNRemoveComponent
_BNRemoveComponent = core.BNRemoveComponent
_BNRemoveComponent.restype = ctypes.c_bool
_BNRemoveComponent.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNComponent),
]
# noinspection PyPep8Naming
def BNRemoveComponent(
view: ctypes.POINTER(BNBinaryView),
component: ctypes.POINTER(BNComponent)
) -> bool:
return _BNRemoveComponent(view, component)
# -------------------------------------------------------
# _BNRemoveComponentByGuid
_BNRemoveComponentByGuid = core.BNRemoveComponentByGuid
_BNRemoveComponentByGuid.restype = ctypes.c_bool
_BNRemoveComponentByGuid.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRemoveComponentByGuid(
view: ctypes.POINTER(BNBinaryView),
guid: Optional[str]
) -> bool:
return _BNRemoveComponentByGuid(view, cstr(guid))
# -------------------------------------------------------
# _BNRemoveDatabaseSnapshot
_BNRemoveDatabaseSnapshot = core.BNRemoveDatabaseSnapshot
_BNRemoveDatabaseSnapshot.restype = ctypes.c_bool
_BNRemoveDatabaseSnapshot.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNRemoveDatabaseSnapshot(
database: ctypes.POINTER(BNDatabase),
id: int
) -> bool:
return _BNRemoveDatabaseSnapshot(database, id)
# -------------------------------------------------------
# _BNRemoveDebugDataVariableByAddress
_BNRemoveDebugDataVariableByAddress = core.BNRemoveDebugDataVariableByAddress
_BNRemoveDebugDataVariableByAddress.restype = ctypes.c_bool
_BNRemoveDebugDataVariableByAddress.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveDebugDataVariableByAddress(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str],
address: int
) -> bool:
return _BNRemoveDebugDataVariableByAddress(debugInfo, cstr(parserName), address)
# -------------------------------------------------------
# _BNRemoveDebugFunctionByIndex
_BNRemoveDebugFunctionByIndex = core.BNRemoveDebugFunctionByIndex
_BNRemoveDebugFunctionByIndex.restype = ctypes.c_bool
_BNRemoveDebugFunctionByIndex.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveDebugFunctionByIndex(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str],
index: int
) -> bool:
return _BNRemoveDebugFunctionByIndex(debugInfo, cstr(parserName), index)
# -------------------------------------------------------
# _BNRemoveDebugParserDataVariables
_BNRemoveDebugParserDataVariables = core.BNRemoveDebugParserDataVariables
_BNRemoveDebugParserDataVariables.restype = ctypes.c_bool
_BNRemoveDebugParserDataVariables.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRemoveDebugParserDataVariables(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str]
) -> bool:
return _BNRemoveDebugParserDataVariables(debugInfo, cstr(parserName))
# -------------------------------------------------------
# _BNRemoveDebugParserFunctions
_BNRemoveDebugParserFunctions = core.BNRemoveDebugParserFunctions
_BNRemoveDebugParserFunctions.restype = ctypes.c_bool
_BNRemoveDebugParserFunctions.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRemoveDebugParserFunctions(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str]
) -> bool:
return _BNRemoveDebugParserFunctions(debugInfo, cstr(parserName))
# -------------------------------------------------------
# _BNRemoveDebugParserInfo
_BNRemoveDebugParserInfo = core.BNRemoveDebugParserInfo
_BNRemoveDebugParserInfo.restype = ctypes.c_bool
_BNRemoveDebugParserInfo.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRemoveDebugParserInfo(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str]
) -> bool:
return _BNRemoveDebugParserInfo(debugInfo, cstr(parserName))
# -------------------------------------------------------
# _BNRemoveDebugParserTypes
_BNRemoveDebugParserTypes = core.BNRemoveDebugParserTypes
_BNRemoveDebugParserTypes.restype = ctypes.c_bool
_BNRemoveDebugParserTypes.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRemoveDebugParserTypes(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str]
) -> bool:
return _BNRemoveDebugParserTypes(debugInfo, cstr(parserName))
# -------------------------------------------------------
# _BNRemoveDebugTypeByName
_BNRemoveDebugTypeByName = core.BNRemoveDebugTypeByName
_BNRemoveDebugTypeByName.restype = ctypes.c_bool
_BNRemoveDebugTypeByName.argtypes = [
ctypes.POINTER(BNDebugInfo),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRemoveDebugTypeByName(
debugInfo: ctypes.POINTER(BNDebugInfo),
parserName: Optional[str],
typeName: Optional[str]
) -> bool:
return _BNRemoveDebugTypeByName(debugInfo, cstr(parserName), cstr(typeName))
# -------------------------------------------------------
# _BNRemoveEnumerationBuilderMember
_BNRemoveEnumerationBuilderMember = core.BNRemoveEnumerationBuilderMember
_BNRemoveEnumerationBuilderMember.restype = None
_BNRemoveEnumerationBuilderMember.argtypes = [
ctypes.POINTER(BNEnumerationBuilder),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveEnumerationBuilderMember(
e: ctypes.POINTER(BNEnumerationBuilder),
idx: int
) -> None:
return _BNRemoveEnumerationBuilderMember(e, idx)
# -------------------------------------------------------
# _BNRemoveExpressionParserMagicValue
_BNRemoveExpressionParserMagicValue = core.BNRemoveExpressionParserMagicValue
_BNRemoveExpressionParserMagicValue.restype = None
_BNRemoveExpressionParserMagicValue.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRemoveExpressionParserMagicValue(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> None:
return _BNRemoveExpressionParserMagicValue(view, cstr(name))
# -------------------------------------------------------
# _BNRemoveExpressionParserMagicValues
_BNRemoveExpressionParserMagicValues = core.BNRemoveExpressionParserMagicValues
_BNRemoveExpressionParserMagicValues.restype = None
_BNRemoveExpressionParserMagicValues.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveExpressionParserMagicValues(
view: ctypes.POINTER(BNBinaryView),
names: ctypes.POINTER(ctypes.c_char_p),
count: int
) -> None:
return _BNRemoveExpressionParserMagicValues(view, names, count)
# -------------------------------------------------------
# _BNRemoveStructureBuilderMember
_BNRemoveStructureBuilderMember = core.BNRemoveStructureBuilderMember
_BNRemoveStructureBuilderMember.restype = None
_BNRemoveStructureBuilderMember.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveStructureBuilderMember(
s: ctypes.POINTER(BNStructureBuilder),
idx: int
) -> None:
return _BNRemoveStructureBuilderMember(s, idx)
# -------------------------------------------------------
# _BNRemoveTag
_BNRemoveTag = core.BNRemoveTag
_BNRemoveTag.restype = None
_BNRemoveTag.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTag),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNRemoveTag(
view: ctypes.POINTER(BNBinaryView),
tag: ctypes.POINTER(BNTag),
user: bool
) -> None:
return _BNRemoveTag(view, tag, user)
# -------------------------------------------------------
# _BNRemoveTagReference
_BNRemoveTagReference = core.BNRemoveTagReference
_BNRemoveTagReference.restype = None
_BNRemoveTagReference.argtypes = [
ctypes.POINTER(BNBinaryView),
BNTagReference,
]
# noinspection PyPep8Naming
def BNRemoveTagReference(
view: ctypes.POINTER(BNBinaryView),
ref: BNTagReference
) -> None:
return _BNRemoveTagReference(view, ref)
# -------------------------------------------------------
# _BNRemoveTagType
_BNRemoveTagType = core.BNRemoveTagType
_BNRemoveTagType.restype = None
_BNRemoveTagType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNRemoveTagType(
view: ctypes.POINTER(BNBinaryView),
tagType: ctypes.POINTER(BNTagType)
) -> None:
return _BNRemoveTagType(view, tagType)
# -------------------------------------------------------
# _BNRemoveUserAddressTag
_BNRemoveUserAddressTag = core.BNRemoveUserAddressTag
_BNRemoveUserAddressTag.restype = None
_BNRemoveUserAddressTag.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNRemoveUserAddressTag(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNRemoveUserAddressTag(func, arch, addr, tag)
# -------------------------------------------------------
# _BNRemoveUserAddressTagsOfType
_BNRemoveUserAddressTagsOfType = core.BNRemoveUserAddressTagsOfType
_BNRemoveUserAddressTagsOfType.restype = None
_BNRemoveUserAddressTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNRemoveUserAddressTagsOfType(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
tagType: ctypes.POINTER(BNTagType)
) -> None:
return _BNRemoveUserAddressTagsOfType(func, arch, addr, tagType)
# -------------------------------------------------------
# _BNRemoveUserCodeReference
_BNRemoveUserCodeReference = core.BNRemoveUserCodeReference
_BNRemoveUserCodeReference.restype = None
_BNRemoveUserCodeReference.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveUserCodeReference(
func: ctypes.POINTER(BNFunction),
fromArch: ctypes.POINTER(BNArchitecture),
fromAddr: int,
toAddr: int
) -> None:
return _BNRemoveUserCodeReference(func, fromArch, fromAddr, toAddr)
# -------------------------------------------------------
# _BNRemoveUserDataReference
_BNRemoveUserDataReference = core.BNRemoveUserDataReference
_BNRemoveUserDataReference.restype = None
_BNRemoveUserDataReference.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveUserDataReference(
view: ctypes.POINTER(BNBinaryView),
fromAddr: int,
toAddr: int
) -> None:
return _BNRemoveUserDataReference(view, fromAddr, toAddr)
# -------------------------------------------------------
# _BNRemoveUserDataTag
_BNRemoveUserDataTag = core.BNRemoveUserDataTag
_BNRemoveUserDataTag.restype = None
_BNRemoveUserDataTag.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNRemoveUserDataTag(
view: ctypes.POINTER(BNBinaryView),
addr: int,
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNRemoveUserDataTag(view, addr, tag)
# -------------------------------------------------------
# _BNRemoveUserDataTagsOfType
_BNRemoveUserDataTagsOfType = core.BNRemoveUserDataTagsOfType
_BNRemoveUserDataTagsOfType.restype = None
_BNRemoveUserDataTagsOfType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNRemoveUserDataTagsOfType(
view: ctypes.POINTER(BNBinaryView),
addr: int,
tagType: ctypes.POINTER(BNTagType)
) -> None:
return _BNRemoveUserDataTagsOfType(view, addr, tagType)
# -------------------------------------------------------
# _BNRemoveUserFunction
_BNRemoveUserFunction = core.BNRemoveUserFunction
_BNRemoveUserFunction.restype = None
_BNRemoveUserFunction.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNRemoveUserFunction(
view: ctypes.POINTER(BNBinaryView),
func: ctypes.POINTER(BNFunction)
) -> None:
return _BNRemoveUserFunction(view, func)
# -------------------------------------------------------
# _BNRemoveUserFunctionTag
_BNRemoveUserFunctionTag = core.BNRemoveUserFunctionTag
_BNRemoveUserFunctionTag.restype = None
_BNRemoveUserFunctionTag.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNRemoveUserFunctionTag(
func: ctypes.POINTER(BNFunction),
tag: ctypes.POINTER(BNTag)
) -> None:
return _BNRemoveUserFunctionTag(func, tag)
# -------------------------------------------------------
# _BNRemoveUserFunctionTagsOfType
_BNRemoveUserFunctionTagsOfType = core.BNRemoveUserFunctionTagsOfType
_BNRemoveUserFunctionTagsOfType.restype = None
_BNRemoveUserFunctionTagsOfType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNRemoveUserFunctionTagsOfType(
func: ctypes.POINTER(BNFunction),
tagType: ctypes.POINTER(BNTagType)
) -> None:
return _BNRemoveUserFunctionTagsOfType(func, tagType)
# -------------------------------------------------------
# _BNRemoveUserSection
_BNRemoveUserSection = core.BNRemoveUserSection
_BNRemoveUserSection.restype = None
_BNRemoveUserSection.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRemoveUserSection(
view: ctypes.POINTER(BNBinaryView),
name: Optional[str]
) -> None:
return _BNRemoveUserSection(view, cstr(name))
# -------------------------------------------------------
# _BNRemoveUserSegment
_BNRemoveUserSegment = core.BNRemoveUserSegment
_BNRemoveUserSegment.restype = None
_BNRemoveUserSegment.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveUserSegment(
view: ctypes.POINTER(BNBinaryView),
start: int,
length: int
) -> None:
return _BNRemoveUserSegment(view, start, length)
# -------------------------------------------------------
# _BNRemoveUserTypeFieldReference
_BNRemoveUserTypeFieldReference = core.BNRemoveUserTypeFieldReference
_BNRemoveUserTypeFieldReference.restype = None
_BNRemoveUserTypeFieldReference.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNQualifiedName),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveUserTypeFieldReference(
func: ctypes.POINTER(BNFunction),
fromArch: ctypes.POINTER(BNArchitecture),
fromAddr: int,
name: ctypes.POINTER(BNQualifiedName),
offset: int,
size: int
) -> None:
return _BNRemoveUserTypeFieldReference(func, fromArch, fromAddr, name, offset, size)
# -------------------------------------------------------
# _BNRemoveUserTypeReference
_BNRemoveUserTypeReference = core.BNRemoveUserTypeReference
_BNRemoveUserTypeReference.restype = None
_BNRemoveUserTypeReference.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNRemoveUserTypeReference(
func: ctypes.POINTER(BNFunction),
fromArch: ctypes.POINTER(BNArchitecture),
fromAddr: int,
name: ctypes.POINTER(BNQualifiedName)
) -> None:
return _BNRemoveUserTypeReference(func, fromArch, fromAddr, name)
# -------------------------------------------------------
# _BNRemoveViewData
_BNRemoveViewData = core.BNRemoveViewData
_BNRemoveViewData.restype = ctypes.c_ulonglong
_BNRemoveViewData.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRemoveViewData(
view: ctypes.POINTER(BNBinaryView),
offset: int,
len: int
) -> int:
return _BNRemoveViewData(view, offset, len)
# -------------------------------------------------------
# _BNRenameAnalysisType
_BNRenameAnalysisType = core.BNRenameAnalysisType
_BNRenameAnalysisType.restype = None
_BNRenameAnalysisType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNRenameAnalysisType(
view: ctypes.POINTER(BNBinaryView),
oldName: ctypes.POINTER(BNQualifiedName),
newName: ctypes.POINTER(BNQualifiedName)
) -> None:
return _BNRenameAnalysisType(view, oldName, newName)
# -------------------------------------------------------
# _BNRenameFile
_BNRenameFile = core.BNRenameFile
_BNRenameFile.restype = ctypes.c_bool
_BNRenameFile.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRenameFile(
source: Optional[str],
dest: Optional[str]
) -> bool:
return _BNRenameFile(cstr(source), cstr(dest))
# -------------------------------------------------------
# _BNRenameTypeArchiveType
_BNRenameTypeArchiveType = core.BNRenameTypeArchiveType
_BNRenameTypeArchiveType.restype = ctypes.c_bool
_BNRenameTypeArchiveType.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNRenameTypeArchiveType(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str],
newName: ctypes.POINTER(BNQualifiedName)
) -> bool:
return _BNRenameTypeArchiveType(archive, cstr(id), newName)
# -------------------------------------------------------
# _BNRenderLinesForData
_BNRenderLinesForData = core.BNRenderLinesForData
_BNRenderLinesForData.restype = ctypes.POINTER(BNDisassemblyTextLine)
_BNRenderLinesForData.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNType),
ctypes.POINTER(BNInstructionTextToken),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(BNTypeContext),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRenderLinesForData(
data: ctypes.POINTER(BNBinaryView),
addr: int,
type: ctypes.POINTER(BNType),
prefix: ctypes.POINTER(BNInstructionTextToken),
prefixCount: int,
width: int,
count: ctypes.POINTER(ctypes.c_ulonglong),
typeCtx: ctypes.POINTER(BNTypeContext),
ctxCount: int
) -> Optional[ctypes.POINTER(BNDisassemblyTextLine)]:
result = _BNRenderLinesForData(data, addr, type, prefix, prefixCount, width, count, typeCtx, ctxCount)
if not result:
return None
return result
# -------------------------------------------------------
# _BNReplaceEnumerationBuilderMember
_BNReplaceEnumerationBuilderMember = core.BNReplaceEnumerationBuilderMember
_BNReplaceEnumerationBuilderMember.restype = None
_BNReplaceEnumerationBuilderMember.argtypes = [
ctypes.POINTER(BNEnumerationBuilder),
ctypes.c_ulonglong,
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReplaceEnumerationBuilderMember(
e: ctypes.POINTER(BNEnumerationBuilder),
idx: int,
name: Optional[str],
value: int
) -> None:
return _BNReplaceEnumerationBuilderMember(e, idx, cstr(name), value)
# -------------------------------------------------------
# _BNReplaceHighLevelILExpr
_BNReplaceHighLevelILExpr = core.BNReplaceHighLevelILExpr
_BNReplaceHighLevelILExpr.restype = None
_BNReplaceHighLevelILExpr.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReplaceHighLevelILExpr(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int,
newExpr: int
) -> None:
return _BNReplaceHighLevelILExpr(func, expr, newExpr)
# -------------------------------------------------------
# _BNReplaceLowLevelILExpr
_BNReplaceLowLevelILExpr = core.BNReplaceLowLevelILExpr
_BNReplaceLowLevelILExpr.restype = None
_BNReplaceLowLevelILExpr.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReplaceLowLevelILExpr(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int,
newExpr: int
) -> None:
return _BNReplaceLowLevelILExpr(func, expr, newExpr)
# -------------------------------------------------------
# _BNReplaceMediumLevelILExpr
_BNReplaceMediumLevelILExpr = core.BNReplaceMediumLevelILExpr
_BNReplaceMediumLevelILExpr.restype = None
_BNReplaceMediumLevelILExpr.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReplaceMediumLevelILExpr(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int,
newExpr: int
) -> None:
return _BNReplaceMediumLevelILExpr(func, expr, newExpr)
# -------------------------------------------------------
# _BNReplaceMediumLevelILInstruction
_BNReplaceMediumLevelILInstruction = core.BNReplaceMediumLevelILInstruction
_BNReplaceMediumLevelILInstruction.restype = None
_BNReplaceMediumLevelILInstruction.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNReplaceMediumLevelILInstruction(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int,
expr: int
) -> None:
return _BNReplaceMediumLevelILInstruction(func, instr, expr)
# -------------------------------------------------------
# _BNReplaceStructureBuilderMember
_BNReplaceStructureBuilderMember = core.BNReplaceStructureBuilderMember
_BNReplaceStructureBuilderMember.restype = None
_BNReplaceStructureBuilderMember.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeWithConfidence),
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNReplaceStructureBuilderMember(
s: ctypes.POINTER(BNStructureBuilder),
idx: int,
type: ctypes.POINTER(BNTypeWithConfidence),
name: Optional[str],
overwriteExisting: bool
) -> None:
return _BNReplaceStructureBuilderMember(s, idx, type, cstr(name), overwriteExisting)
# -------------------------------------------------------
# _BNRepositoryFreePluginDirectoryList
_BNRepositoryFreePluginDirectoryList = core.BNRepositoryFreePluginDirectoryList
_BNRepositoryFreePluginDirectoryList.restype = None
_BNRepositoryFreePluginDirectoryList.argtypes = [
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNRepositoryFreePluginDirectoryList(
list: ctypes.POINTER(ctypes.c_char_p),
count: int
) -> None:
return _BNRepositoryFreePluginDirectoryList(list, count)
# -------------------------------------------------------
# _BNRepositoryGetPluginByPath
_BNRepositoryGetPluginByPath = core.BNRepositoryGetPluginByPath
_BNRepositoryGetPluginByPath.restype = ctypes.POINTER(BNRepoPlugin)
_BNRepositoryGetPluginByPath.argtypes = [
ctypes.POINTER(BNRepository),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRepositoryGetPluginByPath(
r: ctypes.POINTER(BNRepository),
pluginPath: Optional[str]
) -> Optional[ctypes.POINTER(BNRepoPlugin)]:
result = _BNRepositoryGetPluginByPath(r, cstr(pluginPath))
if not result:
return None
return result
# -------------------------------------------------------
# _BNRepositoryGetPlugins
_BNRepositoryGetPlugins = core.BNRepositoryGetPlugins
_BNRepositoryGetPlugins.restype = ctypes.POINTER(ctypes.POINTER(BNRepoPlugin))
_BNRepositoryGetPlugins.argtypes = [
ctypes.POINTER(BNRepository),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNRepositoryGetPlugins(
r: ctypes.POINTER(BNRepository),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNRepoPlugin))]:
result = _BNRepositoryGetPlugins(r, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRepositoryGetPluginsPath
_BNRepositoryGetPluginsPath = core.BNRepositoryGetPluginsPath
_BNRepositoryGetPluginsPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNRepositoryGetPluginsPath.argtypes = [
ctypes.POINTER(BNRepository),
]
# noinspection PyPep8Naming
def BNRepositoryGetPluginsPath(
r: ctypes.POINTER(BNRepository)
) -> Optional[Optional[str]]:
result = _BNRepositoryGetPluginsPath(r)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNRepositoryGetRepoPath
_BNRepositoryGetRepoPath = core.BNRepositoryGetRepoPath
_BNRepositoryGetRepoPath.restype = ctypes.POINTER(ctypes.c_byte)
_BNRepositoryGetRepoPath.argtypes = [
ctypes.POINTER(BNRepository),
]
# noinspection PyPep8Naming
def BNRepositoryGetRepoPath(
r: ctypes.POINTER(BNRepository)
) -> Optional[Optional[str]]:
result = _BNRepositoryGetRepoPath(r)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNRepositoryGetRepositoryByPath
_BNRepositoryGetRepositoryByPath = core.BNRepositoryGetRepositoryByPath
_BNRepositoryGetRepositoryByPath.restype = ctypes.POINTER(BNRepository)
_BNRepositoryGetRepositoryByPath.argtypes = [
ctypes.POINTER(BNRepositoryManager),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRepositoryGetRepositoryByPath(
r: ctypes.POINTER(BNRepositoryManager),
repoPath: Optional[str]
) -> Optional[ctypes.POINTER(BNRepository)]:
result = _BNRepositoryGetRepositoryByPath(r, cstr(repoPath))
if not result:
return None
return result
# -------------------------------------------------------
# _BNRepositoryGetUrl
_BNRepositoryGetUrl = core.BNRepositoryGetUrl
_BNRepositoryGetUrl.restype = ctypes.POINTER(ctypes.c_byte)
_BNRepositoryGetUrl.argtypes = [
ctypes.POINTER(BNRepository),
]
# noinspection PyPep8Naming
def BNRepositoryGetUrl(
r: ctypes.POINTER(BNRepository)
) -> Optional[Optional[str]]:
result = _BNRepositoryGetUrl(r)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNRepositoryManagerAddRepository
_BNRepositoryManagerAddRepository = core.BNRepositoryManagerAddRepository
_BNRepositoryManagerAddRepository.restype = ctypes.c_bool
_BNRepositoryManagerAddRepository.argtypes = [
ctypes.POINTER(BNRepositoryManager),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRepositoryManagerAddRepository(
r: ctypes.POINTER(BNRepositoryManager),
url: Optional[str],
repoPath: Optional[str]
) -> bool:
return _BNRepositoryManagerAddRepository(r, cstr(url), cstr(repoPath))
# -------------------------------------------------------
# _BNRepositoryManagerCheckForUpdates
_BNRepositoryManagerCheckForUpdates = core.BNRepositoryManagerCheckForUpdates
_BNRepositoryManagerCheckForUpdates.restype = ctypes.c_bool
_BNRepositoryManagerCheckForUpdates.argtypes = [
ctypes.POINTER(BNRepositoryManager),
]
# noinspection PyPep8Naming
def BNRepositoryManagerCheckForUpdates(
r: ctypes.POINTER(BNRepositoryManager)
) -> bool:
return _BNRepositoryManagerCheckForUpdates(r)
# -------------------------------------------------------
# _BNRepositoryManagerGetDefaultRepository
_BNRepositoryManagerGetDefaultRepository = core.BNRepositoryManagerGetDefaultRepository
_BNRepositoryManagerGetDefaultRepository.restype = ctypes.POINTER(BNRepository)
_BNRepositoryManagerGetDefaultRepository.argtypes = [
ctypes.POINTER(BNRepositoryManager),
]
# noinspection PyPep8Naming
def BNRepositoryManagerGetDefaultRepository(
r: ctypes.POINTER(BNRepositoryManager)
) -> Optional[ctypes.POINTER(BNRepository)]:
result = _BNRepositoryManagerGetDefaultRepository(r)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRepositoryManagerGetRepositories
_BNRepositoryManagerGetRepositories = core.BNRepositoryManagerGetRepositories
_BNRepositoryManagerGetRepositories.restype = ctypes.POINTER(ctypes.POINTER(BNRepository))
_BNRepositoryManagerGetRepositories.argtypes = [
ctypes.POINTER(BNRepositoryManager),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNRepositoryManagerGetRepositories(
r: ctypes.POINTER(BNRepositoryManager),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.POINTER(BNRepository))]:
result = _BNRepositoryManagerGetRepositories(r, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNRequestAdvancedFunctionAnalysisData
_BNRequestAdvancedFunctionAnalysisData = core.BNRequestAdvancedFunctionAnalysisData
_BNRequestAdvancedFunctionAnalysisData.restype = None
_BNRequestAdvancedFunctionAnalysisData.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNRequestAdvancedFunctionAnalysisData(
func: ctypes.POINTER(BNFunction)
) -> None:
return _BNRequestAdvancedFunctionAnalysisData(func)
# -------------------------------------------------------
# _BNRequestFunctionDebugReport
_BNRequestFunctionDebugReport = core.BNRequestFunctionDebugReport
_BNRequestFunctionDebugReport.restype = None
_BNRequestFunctionDebugReport.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRequestFunctionDebugReport(
func: ctypes.POINTER(BNFunction),
name: Optional[str]
) -> None:
return _BNRequestFunctionDebugReport(func, cstr(name))
# -------------------------------------------------------
# _BNResetDisassemblyTextRendererDeduplicatedComments
_BNResetDisassemblyTextRendererDeduplicatedComments = core.BNResetDisassemblyTextRendererDeduplicatedComments
_BNResetDisassemblyTextRendererDeduplicatedComments.restype = None
_BNResetDisassemblyTextRendererDeduplicatedComments.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
]
# noinspection PyPep8Naming
def BNResetDisassemblyTextRendererDeduplicatedComments(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer)
) -> None:
return _BNResetDisassemblyTextRendererDeduplicatedComments(renderer)
# -------------------------------------------------------
# _BNRevertUndoActions
_BNRevertUndoActions = core.BNRevertUndoActions
_BNRevertUndoActions.restype = None
_BNRevertUndoActions.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRevertUndoActions(
file: ctypes.POINTER(BNFileMetadata),
id: Optional[str]
) -> None:
return _BNRevertUndoActions(file, cstr(id))
# -------------------------------------------------------
# _BNRunProgressDialog
_BNRunProgressDialog = core.BNRunProgressDialog
_BNRunProgressDialog.restype = ctypes.c_bool
_BNRunProgressDialog.argtypes = [
ctypes.c_char_p,
ctypes.c_bool,
ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNRunProgressDialog(
title: Optional[str],
canCancel: bool,
task: ctypes.CFUNCTYPE(None, ctypes.c_void_p, ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong), ctypes.c_void_p),
taskCtxt: Optional[ctypes.c_void_p]
) -> bool:
return _BNRunProgressDialog(cstr(title), canCancel, task, taskCtxt)
# -------------------------------------------------------
# _BNRustSimplifyStrToFQN
_BNRustSimplifyStrToFQN = core.BNRustSimplifyStrToFQN
_BNRustSimplifyStrToFQN.restype = BNQualifiedName
_BNRustSimplifyStrToFQN.argtypes = [
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNRustSimplifyStrToFQN(
arg0: Optional[str],
arg1: bool
) -> BNQualifiedName:
return _BNRustSimplifyStrToFQN(cstr(arg0), arg1)
# -------------------------------------------------------
# _BNRustSimplifyStrToStr
_BNRustSimplifyStrToStr = core.BNRustSimplifyStrToStr
_BNRustSimplifyStrToStr.restype = ctypes.POINTER(ctypes.c_byte)
_BNRustSimplifyStrToStr.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNRustSimplifyStrToStr(
arg0: Optional[str]
) -> Optional[Optional[str]]:
result = _BNRustSimplifyStrToStr(cstr(arg0))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNSaveAutoSnapshot
_BNSaveAutoSnapshot = core.BNSaveAutoSnapshot
_BNSaveAutoSnapshot.restype = ctypes.c_bool
_BNSaveAutoSnapshot.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNSaveSettings),
]
# noinspection PyPep8Naming
def BNSaveAutoSnapshot(
data: ctypes.POINTER(BNBinaryView),
settings: ctypes.POINTER(BNSaveSettings)
) -> bool:
return _BNSaveAutoSnapshot(data, settings)
# -------------------------------------------------------
# _BNSaveAutoSnapshotWithProgress
_BNSaveAutoSnapshotWithProgress = core.BNSaveAutoSnapshotWithProgress
_BNSaveAutoSnapshotWithProgress.restype = ctypes.c_bool
_BNSaveAutoSnapshotWithProgress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.POINTER(BNSaveSettings),
]
# noinspection PyPep8Naming
def BNSaveAutoSnapshotWithProgress(
data: ctypes.POINTER(BNBinaryView),
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
settings: ctypes.POINTER(BNSaveSettings)
) -> bool:
return _BNSaveAutoSnapshotWithProgress(data, ctxt, progress, settings)
# -------------------------------------------------------
# _BNSaveLastRun
_BNSaveLastRun = core.BNSaveLastRun
_BNSaveLastRun.restype = None
_BNSaveLastRun.argtypes = [
]
# noinspection PyPep8Naming
def BNSaveLastRun(
) -> None:
return _BNSaveLastRun()
# -------------------------------------------------------
# _BNSaveToFile
_BNSaveToFile = core.BNSaveToFile
_BNSaveToFile.restype = ctypes.c_bool
_BNSaveToFile.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNFileAccessor),
]
# noinspection PyPep8Naming
def BNSaveToFile(
view: ctypes.POINTER(BNBinaryView),
file: ctypes.POINTER(BNFileAccessor)
) -> bool:
return _BNSaveToFile(view, file)
# -------------------------------------------------------
# _BNSaveToFilename
_BNSaveToFilename = core.BNSaveToFilename
_BNSaveToFilename.restype = ctypes.c_bool
_BNSaveToFilename.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSaveToFilename(
view: ctypes.POINTER(BNBinaryView),
filename: Optional[str]
) -> bool:
return _BNSaveToFilename(view, cstr(filename))
# -------------------------------------------------------
# _BNScriptingInstanceCompleteInput
_BNScriptingInstanceCompleteInput = core.BNScriptingInstanceCompleteInput
_BNScriptingInstanceCompleteInput.restype = ctypes.POINTER(ctypes.c_byte)
_BNScriptingInstanceCompleteInput.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNScriptingInstanceCompleteInput(
instance: ctypes.POINTER(BNScriptingInstance),
text: Optional[str],
state: int
) -> Optional[Optional[str]]:
result = _BNScriptingInstanceCompleteInput(instance, cstr(text), state)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNScriptingInstanceReleaseBinaryView
_BNScriptingInstanceReleaseBinaryView = core.BNScriptingInstanceReleaseBinaryView
_BNScriptingInstanceReleaseBinaryView.restype = None
_BNScriptingInstanceReleaseBinaryView.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNScriptingInstanceReleaseBinaryView(
instance: ctypes.POINTER(BNScriptingInstance),
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNScriptingInstanceReleaseBinaryView(instance, view)
# -------------------------------------------------------
# _BNSearch
_BNSearch = core.BNSearch
_BNSearch.restype = ctypes.c_bool
_BNSearch.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer)),
]
# noinspection PyPep8Naming
def BNSearch(
view: ctypes.POINTER(BNBinaryView),
query: Optional[str],
context: Optional[ctypes.c_void_p],
callback: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.POINTER(BNDataBuffer))
) -> bool:
return _BNSearch(view, cstr(query), context, callback)
# -------------------------------------------------------
# _BNSecretsProviderHasData
_BNSecretsProviderHasData = core.BNSecretsProviderHasData
_BNSecretsProviderHasData.restype = ctypes.c_bool
_BNSecretsProviderHasData.argtypes = [
ctypes.POINTER(BNSecretsProvider),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSecretsProviderHasData(
provider: ctypes.POINTER(BNSecretsProvider),
key: Optional[str]
) -> bool:
return _BNSecretsProviderHasData(provider, cstr(key))
# -------------------------------------------------------
# _BNSectionGetAlign
_BNSectionGetAlign = core.BNSectionGetAlign
_BNSectionGetAlign.restype = ctypes.c_ulonglong
_BNSectionGetAlign.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetAlign(
section: ctypes.POINTER(BNSection)
) -> int:
return _BNSectionGetAlign(section)
# -------------------------------------------------------
# _BNSectionGetEnd
_BNSectionGetEnd = core.BNSectionGetEnd
_BNSectionGetEnd.restype = ctypes.c_ulonglong
_BNSectionGetEnd.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetEnd(
section: ctypes.POINTER(BNSection)
) -> int:
return _BNSectionGetEnd(section)
# -------------------------------------------------------
# _BNSectionGetEntrySize
_BNSectionGetEntrySize = core.BNSectionGetEntrySize
_BNSectionGetEntrySize.restype = ctypes.c_ulonglong
_BNSectionGetEntrySize.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetEntrySize(
section: ctypes.POINTER(BNSection)
) -> int:
return _BNSectionGetEntrySize(section)
# -------------------------------------------------------
# _BNSectionGetInfoData
_BNSectionGetInfoData = core.BNSectionGetInfoData
_BNSectionGetInfoData.restype = ctypes.c_ulonglong
_BNSectionGetInfoData.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetInfoData(
section: ctypes.POINTER(BNSection)
) -> int:
return _BNSectionGetInfoData(section)
# -------------------------------------------------------
# _BNSectionGetInfoSection
_BNSectionGetInfoSection = core.BNSectionGetInfoSection
_BNSectionGetInfoSection.restype = ctypes.POINTER(ctypes.c_byte)
_BNSectionGetInfoSection.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetInfoSection(
section: ctypes.POINTER(BNSection)
) -> Optional[Optional[str]]:
result = _BNSectionGetInfoSection(section)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNSectionGetLength
_BNSectionGetLength = core.BNSectionGetLength
_BNSectionGetLength.restype = ctypes.c_ulonglong
_BNSectionGetLength.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetLength(
section: ctypes.POINTER(BNSection)
) -> int:
return _BNSectionGetLength(section)
# -------------------------------------------------------
# _BNSectionGetLinkedSection
_BNSectionGetLinkedSection = core.BNSectionGetLinkedSection
_BNSectionGetLinkedSection.restype = ctypes.POINTER(ctypes.c_byte)
_BNSectionGetLinkedSection.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetLinkedSection(
section: ctypes.POINTER(BNSection)
) -> Optional[Optional[str]]:
result = _BNSectionGetLinkedSection(section)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNSectionGetName
_BNSectionGetName = core.BNSectionGetName
_BNSectionGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNSectionGetName.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetName(
section: ctypes.POINTER(BNSection)
) -> Optional[Optional[str]]:
result = _BNSectionGetName(section)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNSectionGetSemantics
_BNSectionGetSemantics = core.BNSectionGetSemantics
_BNSectionGetSemantics.restype = SectionSemanticsEnum
_BNSectionGetSemantics.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetSemantics(
section: ctypes.POINTER(BNSection)
) -> SectionSemantics:
return _BNSectionGetSemantics(section)
# -------------------------------------------------------
# _BNSectionGetStart
_BNSectionGetStart = core.BNSectionGetStart
_BNSectionGetStart.restype = ctypes.c_ulonglong
_BNSectionGetStart.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetStart(
section: ctypes.POINTER(BNSection)
) -> int:
return _BNSectionGetStart(section)
# -------------------------------------------------------
# _BNSectionGetType
_BNSectionGetType = core.BNSectionGetType
_BNSectionGetType.restype = ctypes.POINTER(ctypes.c_byte)
_BNSectionGetType.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionGetType(
section: ctypes.POINTER(BNSection)
) -> Optional[Optional[str]]:
result = _BNSectionGetType(section)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNSectionIsAutoDefined
_BNSectionIsAutoDefined = core.BNSectionIsAutoDefined
_BNSectionIsAutoDefined.restype = ctypes.c_bool
_BNSectionIsAutoDefined.argtypes = [
ctypes.POINTER(BNSection),
]
# noinspection PyPep8Naming
def BNSectionIsAutoDefined(
section: ctypes.POINTER(BNSection)
) -> bool:
return _BNSectionIsAutoDefined(section)
# -------------------------------------------------------
# _BNSeekBinaryReader
_BNSeekBinaryReader = core.BNSeekBinaryReader
_BNSeekBinaryReader.restype = None
_BNSeekBinaryReader.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSeekBinaryReader(
stream: ctypes.POINTER(BNBinaryReader),
offset: int
) -> None:
return _BNSeekBinaryReader(stream, offset)
# -------------------------------------------------------
# _BNSeekBinaryReaderRelative
_BNSeekBinaryReaderRelative = core.BNSeekBinaryReaderRelative
_BNSeekBinaryReaderRelative.restype = None
_BNSeekBinaryReaderRelative.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNSeekBinaryReaderRelative(
stream: ctypes.POINTER(BNBinaryReader),
offset: int
) -> None:
return _BNSeekBinaryReaderRelative(stream, offset)
# -------------------------------------------------------
# _BNSeekBinaryWriter
_BNSeekBinaryWriter = core.BNSeekBinaryWriter
_BNSeekBinaryWriter.restype = None
_BNSeekBinaryWriter.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSeekBinaryWriter(
stream: ctypes.POINTER(BNBinaryWriter),
offset: int
) -> None:
return _BNSeekBinaryWriter(stream, offset)
# -------------------------------------------------------
# _BNSeekBinaryWriterRelative
_BNSeekBinaryWriterRelative = core.BNSeekBinaryWriterRelative
_BNSeekBinaryWriterRelative.restype = None
_BNSeekBinaryWriterRelative.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNSeekBinaryWriterRelative(
stream: ctypes.POINTER(BNBinaryWriter),
offset: int
) -> None:
return _BNSeekBinaryWriterRelative(stream, offset)
# -------------------------------------------------------
# _BNSeekLinearViewCursorToAddress
_BNSeekLinearViewCursorToAddress = core.BNSeekLinearViewCursorToAddress
_BNSeekLinearViewCursorToAddress.restype = None
_BNSeekLinearViewCursorToAddress.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSeekLinearViewCursorToAddress(
cursor: ctypes.POINTER(BNLinearViewCursor),
addr: int
) -> None:
return _BNSeekLinearViewCursorToAddress(cursor, addr)
# -------------------------------------------------------
# _BNSeekLinearViewCursorToBegin
_BNSeekLinearViewCursorToBegin = core.BNSeekLinearViewCursorToBegin
_BNSeekLinearViewCursorToBegin.restype = None
_BNSeekLinearViewCursorToBegin.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNSeekLinearViewCursorToBegin(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> None:
return _BNSeekLinearViewCursorToBegin(cursor)
# -------------------------------------------------------
# _BNSeekLinearViewCursorToCursorPath
_BNSeekLinearViewCursorToCursorPath = core.BNSeekLinearViewCursorToCursorPath
_BNSeekLinearViewCursorToCursorPath.restype = ctypes.c_bool
_BNSeekLinearViewCursorToCursorPath.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNSeekLinearViewCursorToCursorPath(
cursor: ctypes.POINTER(BNLinearViewCursor),
path: ctypes.POINTER(BNLinearViewCursor)
) -> bool:
return _BNSeekLinearViewCursorToCursorPath(cursor, path)
# -------------------------------------------------------
# _BNSeekLinearViewCursorToCursorPathAndAddress
_BNSeekLinearViewCursorToCursorPathAndAddress = core.BNSeekLinearViewCursorToCursorPathAndAddress
_BNSeekLinearViewCursorToCursorPathAndAddress.restype = ctypes.c_bool
_BNSeekLinearViewCursorToCursorPathAndAddress.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.POINTER(BNLinearViewCursor),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSeekLinearViewCursorToCursorPathAndAddress(
cursor: ctypes.POINTER(BNLinearViewCursor),
path: ctypes.POINTER(BNLinearViewCursor),
addr: int
) -> bool:
return _BNSeekLinearViewCursorToCursorPathAndAddress(cursor, path, addr)
# -------------------------------------------------------
# _BNSeekLinearViewCursorToEnd
_BNSeekLinearViewCursorToEnd = core.BNSeekLinearViewCursorToEnd
_BNSeekLinearViewCursorToEnd.restype = None
_BNSeekLinearViewCursorToEnd.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
]
# noinspection PyPep8Naming
def BNSeekLinearViewCursorToEnd(
cursor: ctypes.POINTER(BNLinearViewCursor)
) -> None:
return _BNSeekLinearViewCursorToEnd(cursor)
# -------------------------------------------------------
# _BNSeekLinearViewCursorToOrderingIndex
_BNSeekLinearViewCursorToOrderingIndex = core.BNSeekLinearViewCursorToOrderingIndex
_BNSeekLinearViewCursorToOrderingIndex.restype = None
_BNSeekLinearViewCursorToOrderingIndex.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSeekLinearViewCursorToOrderingIndex(
cursor: ctypes.POINTER(BNLinearViewCursor),
idx: int
) -> None:
return _BNSeekLinearViewCursorToOrderingIndex(cursor, idx)
# -------------------------------------------------------
# _BNSeekLinearViewCursorToPath
_BNSeekLinearViewCursorToPath = core.BNSeekLinearViewCursorToPath
_BNSeekLinearViewCursorToPath.restype = ctypes.c_bool
_BNSeekLinearViewCursorToPath.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.POINTER(BNLinearViewObjectIdentifier),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSeekLinearViewCursorToPath(
cursor: ctypes.POINTER(BNLinearViewCursor),
ids: ctypes.POINTER(BNLinearViewObjectIdentifier),
count: int
) -> bool:
return _BNSeekLinearViewCursorToPath(cursor, ids, count)
# -------------------------------------------------------
# _BNSeekLinearViewCursorToPathAndAddress
_BNSeekLinearViewCursorToPathAndAddress = core.BNSeekLinearViewCursorToPathAndAddress
_BNSeekLinearViewCursorToPathAndAddress.restype = ctypes.c_bool
_BNSeekLinearViewCursorToPathAndAddress.argtypes = [
ctypes.POINTER(BNLinearViewCursor),
ctypes.POINTER(BNLinearViewObjectIdentifier),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSeekLinearViewCursorToPathAndAddress(
cursor: ctypes.POINTER(BNLinearViewCursor),
ids: ctypes.POINTER(BNLinearViewObjectIdentifier),
count: int,
addr: int
) -> bool:
return _BNSeekLinearViewCursorToPathAndAddress(cursor, ids, count, addr)
# -------------------------------------------------------
# _BNSegmentGetDataEnd
_BNSegmentGetDataEnd = core.BNSegmentGetDataEnd
_BNSegmentGetDataEnd.restype = ctypes.c_ulonglong
_BNSegmentGetDataEnd.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNSegmentGetDataEnd(
segment: ctypes.POINTER(BNSegment)
) -> int:
return _BNSegmentGetDataEnd(segment)
# -------------------------------------------------------
# _BNSegmentGetDataLength
_BNSegmentGetDataLength = core.BNSegmentGetDataLength
_BNSegmentGetDataLength.restype = ctypes.c_ulonglong
_BNSegmentGetDataLength.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNSegmentGetDataLength(
segment: ctypes.POINTER(BNSegment)
) -> int:
return _BNSegmentGetDataLength(segment)
# -------------------------------------------------------
# _BNSegmentGetDataOffset
_BNSegmentGetDataOffset = core.BNSegmentGetDataOffset
_BNSegmentGetDataOffset.restype = ctypes.c_ulonglong
_BNSegmentGetDataOffset.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNSegmentGetDataOffset(
segment: ctypes.POINTER(BNSegment)
) -> int:
return _BNSegmentGetDataOffset(segment)
# -------------------------------------------------------
# _BNSegmentGetEnd
_BNSegmentGetEnd = core.BNSegmentGetEnd
_BNSegmentGetEnd.restype = ctypes.c_ulonglong
_BNSegmentGetEnd.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNSegmentGetEnd(
segment: ctypes.POINTER(BNSegment)
) -> int:
return _BNSegmentGetEnd(segment)
# -------------------------------------------------------
# _BNSegmentGetFlags
_BNSegmentGetFlags = core.BNSegmentGetFlags
_BNSegmentGetFlags.restype = ctypes.c_uint
_BNSegmentGetFlags.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNSegmentGetFlags(
segment: ctypes.POINTER(BNSegment)
) -> int:
return _BNSegmentGetFlags(segment)
# -------------------------------------------------------
# _BNSegmentGetLength
_BNSegmentGetLength = core.BNSegmentGetLength
_BNSegmentGetLength.restype = ctypes.c_ulonglong
_BNSegmentGetLength.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNSegmentGetLength(
segment: ctypes.POINTER(BNSegment)
) -> int:
return _BNSegmentGetLength(segment)
# -------------------------------------------------------
# _BNSegmentGetRelocationRanges
_BNSegmentGetRelocationRanges = core.BNSegmentGetRelocationRanges
_BNSegmentGetRelocationRanges.restype = ctypes.POINTER(BNRange)
_BNSegmentGetRelocationRanges.argtypes = [
ctypes.POINTER(BNSegment),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNSegmentGetRelocationRanges(
segment: ctypes.POINTER(BNSegment),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNRange)]:
result = _BNSegmentGetRelocationRanges(segment, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNSegmentGetRelocationRangesAtAddress
_BNSegmentGetRelocationRangesAtAddress = core.BNSegmentGetRelocationRangesAtAddress
_BNSegmentGetRelocationRangesAtAddress.restype = ctypes.POINTER(BNRange)
_BNSegmentGetRelocationRangesAtAddress.argtypes = [
ctypes.POINTER(BNSegment),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNSegmentGetRelocationRangesAtAddress(
segment: ctypes.POINTER(BNSegment),
addr: int,
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(BNRange)]:
result = _BNSegmentGetRelocationRangesAtAddress(segment, addr, count)
if not result:
return None
return result
# -------------------------------------------------------
# _BNSegmentGetRelocationsCount
_BNSegmentGetRelocationsCount = core.BNSegmentGetRelocationsCount
_BNSegmentGetRelocationsCount.restype = ctypes.c_ulonglong
_BNSegmentGetRelocationsCount.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNSegmentGetRelocationsCount(
segment: ctypes.POINTER(BNSegment)
) -> int:
return _BNSegmentGetRelocationsCount(segment)
# -------------------------------------------------------
# _BNSegmentGetStart
_BNSegmentGetStart = core.BNSegmentGetStart
_BNSegmentGetStart.restype = ctypes.c_ulonglong
_BNSegmentGetStart.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNSegmentGetStart(
segment: ctypes.POINTER(BNSegment)
) -> int:
return _BNSegmentGetStart(segment)
# -------------------------------------------------------
# _BNSegmentIsAutoDefined
_BNSegmentIsAutoDefined = core.BNSegmentIsAutoDefined
_BNSegmentIsAutoDefined.restype = ctypes.c_bool
_BNSegmentIsAutoDefined.argtypes = [
ctypes.POINTER(BNSegment),
]
# noinspection PyPep8Naming
def BNSegmentIsAutoDefined(
segment: ctypes.POINTER(BNSegment)
) -> bool:
return _BNSegmentIsAutoDefined(segment)
# -------------------------------------------------------
# _BNSegmentRangeContainsRelocation
_BNSegmentRangeContainsRelocation = core.BNSegmentRangeContainsRelocation
_BNSegmentRangeContainsRelocation.restype = ctypes.c_bool
_BNSegmentRangeContainsRelocation.argtypes = [
ctypes.POINTER(BNSegment),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSegmentRangeContainsRelocation(
segment: ctypes.POINTER(BNSegment),
addr: int,
size: int
) -> bool:
return _BNSegmentRangeContainsRelocation(segment, addr, size)
# -------------------------------------------------------
# _BNSegmentSetDataLength
_BNSegmentSetDataLength = core.BNSegmentSetDataLength
_BNSegmentSetDataLength.restype = None
_BNSegmentSetDataLength.argtypes = [
ctypes.POINTER(BNSegment),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSegmentSetDataLength(
segment: ctypes.POINTER(BNSegment),
dataLength: int
) -> None:
return _BNSegmentSetDataLength(segment, dataLength)
# -------------------------------------------------------
# _BNSegmentSetDataOffset
_BNSegmentSetDataOffset = core.BNSegmentSetDataOffset
_BNSegmentSetDataOffset.restype = None
_BNSegmentSetDataOffset.argtypes = [
ctypes.POINTER(BNSegment),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSegmentSetDataOffset(
segment: ctypes.POINTER(BNSegment),
dataOffset: int
) -> None:
return _BNSegmentSetDataOffset(segment, dataOffset)
# -------------------------------------------------------
# _BNSegmentSetFlags
_BNSegmentSetFlags = core.BNSegmentSetFlags
_BNSegmentSetFlags.restype = None
_BNSegmentSetFlags.argtypes = [
ctypes.POINTER(BNSegment),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNSegmentSetFlags(
segment: ctypes.POINTER(BNSegment),
flags: int
) -> None:
return _BNSegmentSetFlags(segment, flags)
# -------------------------------------------------------
# _BNSegmentSetLength
_BNSegmentSetLength = core.BNSegmentSetLength
_BNSegmentSetLength.restype = None
_BNSegmentSetLength.argtypes = [
ctypes.POINTER(BNSegment),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSegmentSetLength(
segment: ctypes.POINTER(BNSegment),
length: int
) -> None:
return _BNSegmentSetLength(segment, length)
# -------------------------------------------------------
# _BNSerializeSettings
_BNSerializeSettings = core.BNSerializeSettings
_BNSerializeSettings.restype = ctypes.POINTER(ctypes.c_byte)
_BNSerializeSettings.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
]
# noinspection PyPep8Naming
def BNSerializeSettings(
settings: ctypes.POINTER(BNSettings),
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope
) -> Optional[Optional[str]]:
result = _BNSerializeSettings(settings, view, scope)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNSetActiveUpdateChannel
_BNSetActiveUpdateChannel = core.BNSetActiveUpdateChannel
_BNSetActiveUpdateChannel.restype = None
_BNSetActiveUpdateChannel.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetActiveUpdateChannel(
channel: Optional[str]
) -> None:
return _BNSetActiveUpdateChannel(cstr(channel))
# -------------------------------------------------------
# _BNSetAnalysisHold
_BNSetAnalysisHold = core.BNSetAnalysisHold
_BNSetAnalysisHold.restype = None
_BNSetAnalysisHold.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSetAnalysisHold(
view: ctypes.POINTER(BNBinaryView),
enable: bool
) -> None:
return _BNSetAnalysisHold(view, enable)
# -------------------------------------------------------
# _BNSetArchitectureCdeclCallingConvention
_BNSetArchitectureCdeclCallingConvention = core.BNSetArchitectureCdeclCallingConvention
_BNSetArchitectureCdeclCallingConvention.restype = None
_BNSetArchitectureCdeclCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNSetArchitectureCdeclCallingConvention(
arch: ctypes.POINTER(BNArchitecture),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNSetArchitectureCdeclCallingConvention(arch, cc)
# -------------------------------------------------------
# _BNSetArchitectureDefaultCallingConvention
_BNSetArchitectureDefaultCallingConvention = core.BNSetArchitectureDefaultCallingConvention
_BNSetArchitectureDefaultCallingConvention.restype = None
_BNSetArchitectureDefaultCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNSetArchitectureDefaultCallingConvention(
arch: ctypes.POINTER(BNArchitecture),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNSetArchitectureDefaultCallingConvention(arch, cc)
# -------------------------------------------------------
# _BNSetArchitectureFastcallCallingConvention
_BNSetArchitectureFastcallCallingConvention = core.BNSetArchitectureFastcallCallingConvention
_BNSetArchitectureFastcallCallingConvention.restype = None
_BNSetArchitectureFastcallCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNSetArchitectureFastcallCallingConvention(
arch: ctypes.POINTER(BNArchitecture),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNSetArchitectureFastcallCallingConvention(arch, cc)
# -------------------------------------------------------
# _BNSetArchitectureStdcallCallingConvention
_BNSetArchitectureStdcallCallingConvention = core.BNSetArchitectureStdcallCallingConvention
_BNSetArchitectureStdcallCallingConvention.restype = None
_BNSetArchitectureStdcallCallingConvention.argtypes = [
ctypes.POINTER(BNArchitecture),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNSetArchitectureStdcallCallingConvention(
arch: ctypes.POINTER(BNArchitecture),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNSetArchitectureStdcallCallingConvention(arch, cc)
# -------------------------------------------------------
# _BNSetAutoBasicBlockHighlight
_BNSetAutoBasicBlockHighlight = core.BNSetAutoBasicBlockHighlight
_BNSetAutoBasicBlockHighlight.restype = None
_BNSetAutoBasicBlockHighlight.argtypes = [
ctypes.POINTER(BNBasicBlock),
BNHighlightColor,
]
# noinspection PyPep8Naming
def BNSetAutoBasicBlockHighlight(
block: ctypes.POINTER(BNBasicBlock),
color: BNHighlightColor
) -> None:
return _BNSetAutoBasicBlockHighlight(block, color)
# -------------------------------------------------------
# _BNSetAutoCallRegisterStackAdjustment
_BNSetAutoCallRegisterStackAdjustment = core.BNSetAutoCallRegisterStackAdjustment
_BNSetAutoCallRegisterStackAdjustment.restype = None
_BNSetAutoCallRegisterStackAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNRegisterStackAdjustment),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetAutoCallRegisterStackAdjustment(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
adjust: ctypes.POINTER(BNRegisterStackAdjustment),
count: int
) -> None:
return _BNSetAutoCallRegisterStackAdjustment(func, arch, addr, adjust, count)
# -------------------------------------------------------
# _BNSetAutoCallRegisterStackAdjustmentForRegisterStack
_BNSetAutoCallRegisterStackAdjustmentForRegisterStack = core.BNSetAutoCallRegisterStackAdjustmentForRegisterStack
_BNSetAutoCallRegisterStackAdjustmentForRegisterStack.restype = None
_BNSetAutoCallRegisterStackAdjustmentForRegisterStack.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.c_int,
ctypes.c_ubyte,
]
# noinspection PyPep8Naming
def BNSetAutoCallRegisterStackAdjustmentForRegisterStack(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
regStack: int,
adjust: int,
confidence: int
) -> None:
return _BNSetAutoCallRegisterStackAdjustmentForRegisterStack(func, arch, addr, regStack, adjust, confidence)
# -------------------------------------------------------
# _BNSetAutoCallStackAdjustment
_BNSetAutoCallStackAdjustment = core.BNSetAutoCallStackAdjustment
_BNSetAutoCallStackAdjustment.restype = None
_BNSetAutoCallStackAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_longlong,
ctypes.c_ubyte,
]
# noinspection PyPep8Naming
def BNSetAutoCallStackAdjustment(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
adjust: int,
confidence: int
) -> None:
return _BNSetAutoCallStackAdjustment(func, arch, addr, adjust, confidence)
# -------------------------------------------------------
# _BNSetAutoCallTypeAdjustment
_BNSetAutoCallTypeAdjustment = core.BNSetAutoCallTypeAdjustment
_BNSetAutoCallTypeAdjustment.restype = None
_BNSetAutoCallTypeAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoCallTypeAdjustment(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
type: ctypes.POINTER(BNTypeWithConfidence)
) -> None:
return _BNSetAutoCallTypeAdjustment(func, arch, addr, type)
# -------------------------------------------------------
# _BNSetAutoFunctionCallingConvention
_BNSetAutoFunctionCallingConvention = core.BNSetAutoFunctionCallingConvention
_BNSetAutoFunctionCallingConvention.restype = None
_BNSetAutoFunctionCallingConvention.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNCallingConventionWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoFunctionCallingConvention(
func: ctypes.POINTER(BNFunction),
convention: ctypes.POINTER(BNCallingConventionWithConfidence)
) -> None:
return _BNSetAutoFunctionCallingConvention(func, convention)
# -------------------------------------------------------
# _BNSetAutoFunctionCanReturn
_BNSetAutoFunctionCanReturn = core.BNSetAutoFunctionCanReturn
_BNSetAutoFunctionCanReturn.restype = None
_BNSetAutoFunctionCanReturn.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoFunctionCanReturn(
func: ctypes.POINTER(BNFunction),
returns: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNSetAutoFunctionCanReturn(func, returns)
# -------------------------------------------------------
# _BNSetAutoFunctionClobberedRegisters
_BNSetAutoFunctionClobberedRegisters = core.BNSetAutoFunctionClobberedRegisters
_BNSetAutoFunctionClobberedRegisters.restype = None
_BNSetAutoFunctionClobberedRegisters.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNRegisterSetWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoFunctionClobberedRegisters(
func: ctypes.POINTER(BNFunction),
regs: ctypes.POINTER(BNRegisterSetWithConfidence)
) -> None:
return _BNSetAutoFunctionClobberedRegisters(func, regs)
# -------------------------------------------------------
# _BNSetAutoFunctionHasVariableArguments
_BNSetAutoFunctionHasVariableArguments = core.BNSetAutoFunctionHasVariableArguments
_BNSetAutoFunctionHasVariableArguments.restype = None
_BNSetAutoFunctionHasVariableArguments.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoFunctionHasVariableArguments(
func: ctypes.POINTER(BNFunction),
varArgs: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNSetAutoFunctionHasVariableArguments(func, varArgs)
# -------------------------------------------------------
# _BNSetAutoFunctionInlinedDuringAnalysis
_BNSetAutoFunctionInlinedDuringAnalysis = core.BNSetAutoFunctionInlinedDuringAnalysis
_BNSetAutoFunctionInlinedDuringAnalysis.restype = None
_BNSetAutoFunctionInlinedDuringAnalysis.argtypes = [
ctypes.POINTER(BNFunction),
BNBoolWithConfidence,
]
# noinspection PyPep8Naming
def BNSetAutoFunctionInlinedDuringAnalysis(
func: ctypes.POINTER(BNFunction),
inlined: BNBoolWithConfidence
) -> None:
return _BNSetAutoFunctionInlinedDuringAnalysis(func, inlined)
# -------------------------------------------------------
# _BNSetAutoFunctionParameterVariables
_BNSetAutoFunctionParameterVariables = core.BNSetAutoFunctionParameterVariables
_BNSetAutoFunctionParameterVariables.restype = None
_BNSetAutoFunctionParameterVariables.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNParameterVariablesWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoFunctionParameterVariables(
func: ctypes.POINTER(BNFunction),
vars: ctypes.POINTER(BNParameterVariablesWithConfidence)
) -> None:
return _BNSetAutoFunctionParameterVariables(func, vars)
# -------------------------------------------------------
# _BNSetAutoFunctionPure
_BNSetAutoFunctionPure = core.BNSetAutoFunctionPure
_BNSetAutoFunctionPure.restype = None
_BNSetAutoFunctionPure.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoFunctionPure(
func: ctypes.POINTER(BNFunction),
pure: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNSetAutoFunctionPure(func, pure)
# -------------------------------------------------------
# _BNSetAutoFunctionRegisterStackAdjustments
_BNSetAutoFunctionRegisterStackAdjustments = core.BNSetAutoFunctionRegisterStackAdjustments
_BNSetAutoFunctionRegisterStackAdjustments.restype = None
_BNSetAutoFunctionRegisterStackAdjustments.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNRegisterStackAdjustment),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetAutoFunctionRegisterStackAdjustments(
func: ctypes.POINTER(BNFunction),
adjustments: ctypes.POINTER(BNRegisterStackAdjustment),
count: int
) -> None:
return _BNSetAutoFunctionRegisterStackAdjustments(func, adjustments, count)
# -------------------------------------------------------
# _BNSetAutoFunctionReturnRegisters
_BNSetAutoFunctionReturnRegisters = core.BNSetAutoFunctionReturnRegisters
_BNSetAutoFunctionReturnRegisters.restype = None
_BNSetAutoFunctionReturnRegisters.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNRegisterSetWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoFunctionReturnRegisters(
func: ctypes.POINTER(BNFunction),
regs: ctypes.POINTER(BNRegisterSetWithConfidence)
) -> None:
return _BNSetAutoFunctionReturnRegisters(func, regs)
# -------------------------------------------------------
# _BNSetAutoFunctionReturnType
_BNSetAutoFunctionReturnType = core.BNSetAutoFunctionReturnType
_BNSetAutoFunctionReturnType.restype = None
_BNSetAutoFunctionReturnType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTypeWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoFunctionReturnType(
func: ctypes.POINTER(BNFunction),
type: ctypes.POINTER(BNTypeWithConfidence)
) -> None:
return _BNSetAutoFunctionReturnType(func, type)
# -------------------------------------------------------
# _BNSetAutoFunctionStackAdjustment
_BNSetAutoFunctionStackAdjustment = core.BNSetAutoFunctionStackAdjustment
_BNSetAutoFunctionStackAdjustment.restype = None
_BNSetAutoFunctionStackAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNOffsetWithConfidence),
]
# noinspection PyPep8Naming
def BNSetAutoFunctionStackAdjustment(
func: ctypes.POINTER(BNFunction),
stackAdjust: ctypes.POINTER(BNOffsetWithConfidence)
) -> None:
return _BNSetAutoFunctionStackAdjustment(func, stackAdjust)
# -------------------------------------------------------
# _BNSetAutoIndirectBranches
_BNSetAutoIndirectBranches = core.BNSetAutoIndirectBranches
_BNSetAutoIndirectBranches.restype = None
_BNSetAutoIndirectBranches.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNArchitectureAndAddress),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetAutoIndirectBranches(
func: ctypes.POINTER(BNFunction),
sourceArch: ctypes.POINTER(BNArchitecture),
source: int,
branches: ctypes.POINTER(BNArchitectureAndAddress),
count: int
) -> None:
return _BNSetAutoIndirectBranches(func, sourceArch, source, branches, count)
# -------------------------------------------------------
# _BNSetAutoInstructionHighlight
_BNSetAutoInstructionHighlight = core.BNSetAutoInstructionHighlight
_BNSetAutoInstructionHighlight.restype = None
_BNSetAutoInstructionHighlight.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
BNHighlightColor,
]
# noinspection PyPep8Naming
def BNSetAutoInstructionHighlight(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
color: BNHighlightColor
) -> None:
return _BNSetAutoInstructionHighlight(func, arch, addr, color)
# -------------------------------------------------------
# _BNSetAutoUpdatesEnabled
_BNSetAutoUpdatesEnabled = core.BNSetAutoUpdatesEnabled
_BNSetAutoUpdatesEnabled.restype = None
_BNSetAutoUpdatesEnabled.argtypes = [
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSetAutoUpdatesEnabled(
enabled: bool
) -> None:
return _BNSetAutoUpdatesEnabled(enabled)
# -------------------------------------------------------
# _BNSetBackgroundTaskProgressText
_BNSetBackgroundTaskProgressText = core.BNSetBackgroundTaskProgressText
_BNSetBackgroundTaskProgressText.restype = None
_BNSetBackgroundTaskProgressText.argtypes = [
ctypes.POINTER(BNBackgroundTask),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetBackgroundTaskProgressText(
task: ctypes.POINTER(BNBackgroundTask),
text: Optional[str]
) -> None:
return _BNSetBackgroundTaskProgressText(task, cstr(text))
# -------------------------------------------------------
# _BNSetBaseStructuresForStructureBuilder
_BNSetBaseStructuresForStructureBuilder = core.BNSetBaseStructuresForStructureBuilder
_BNSetBaseStructuresForStructureBuilder.restype = None
_BNSetBaseStructuresForStructureBuilder.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.POINTER(BNBaseStructure),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetBaseStructuresForStructureBuilder(
s: ctypes.POINTER(BNStructureBuilder),
bases: ctypes.POINTER(BNBaseStructure),
count: int
) -> None:
return _BNSetBaseStructuresForStructureBuilder(s, bases, count)
# -------------------------------------------------------
# _BNSetBasicBlockList
_BNSetBasicBlockList = core.BNSetBasicBlockList
_BNSetBasicBlockList.restype = None
_BNSetBasicBlockList.argtypes = [
ctypes.POINTER(BNAnalysisContext),
ctypes.POINTER(ctypes.POINTER(BNBasicBlock)),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetBasicBlockList(
analysisContext: ctypes.POINTER(BNAnalysisContext),
basicBlocks: ctypes.POINTER(ctypes.POINTER(BNBasicBlock)),
count: int
) -> None:
return _BNSetBasicBlockList(analysisContext, basicBlocks, count)
# -------------------------------------------------------
# _BNSetBinaryReaderEndianness
_BNSetBinaryReaderEndianness = core.BNSetBinaryReaderEndianness
_BNSetBinaryReaderEndianness.restype = None
_BNSetBinaryReaderEndianness.argtypes = [
ctypes.POINTER(BNBinaryReader),
EndiannessEnum,
]
# noinspection PyPep8Naming
def BNSetBinaryReaderEndianness(
stream: ctypes.POINTER(BNBinaryReader),
endian: Endianness
) -> None:
return _BNSetBinaryReaderEndianness(stream, endian)
# -------------------------------------------------------
# _BNSetBinaryReaderVirtualBase
_BNSetBinaryReaderVirtualBase = core.BNSetBinaryReaderVirtualBase
_BNSetBinaryReaderVirtualBase.restype = None
_BNSetBinaryReaderVirtualBase.argtypes = [
ctypes.POINTER(BNBinaryReader),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetBinaryReaderVirtualBase(
stream: ctypes.POINTER(BNBinaryReader),
base: int
) -> None:
return _BNSetBinaryReaderVirtualBase(stream, base)
# -------------------------------------------------------
# _BNSetBinaryWriterEndianness
_BNSetBinaryWriterEndianness = core.BNSetBinaryWriterEndianness
_BNSetBinaryWriterEndianness.restype = None
_BNSetBinaryWriterEndianness.argtypes = [
ctypes.POINTER(BNBinaryWriter),
EndiannessEnum,
]
# noinspection PyPep8Naming
def BNSetBinaryWriterEndianness(
stream: ctypes.POINTER(BNBinaryWriter),
endian: Endianness
) -> None:
return _BNSetBinaryWriterEndianness(stream, endian)
# -------------------------------------------------------
# _BNSetBundledPluginDirectory
_BNSetBundledPluginDirectory = core.BNSetBundledPluginDirectory
_BNSetBundledPluginDirectory.restype = None
_BNSetBundledPluginDirectory.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetBundledPluginDirectory(
path: Optional[str]
) -> None:
return _BNSetBundledPluginDirectory(cstr(path))
# -------------------------------------------------------
# _BNSetCommentForAddress
_BNSetCommentForAddress = core.BNSetCommentForAddress
_BNSetCommentForAddress.restype = None
_BNSetCommentForAddress.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetCommentForAddress(
func: ctypes.POINTER(BNFunction),
addr: int,
comment: Optional[str]
) -> None:
return _BNSetCommentForAddress(func, addr, cstr(comment))
# -------------------------------------------------------
# _BNSetCurrentPluginLoadOrder
_BNSetCurrentPluginLoadOrder = core.BNSetCurrentPluginLoadOrder
_BNSetCurrentPluginLoadOrder.restype = None
_BNSetCurrentPluginLoadOrder.argtypes = [
PluginLoadOrderEnum,
]
# noinspection PyPep8Naming
def BNSetCurrentPluginLoadOrder(
order: PluginLoadOrder
) -> None:
return _BNSetCurrentPluginLoadOrder(order)
# -------------------------------------------------------
# _BNSetDataBufferByte
_BNSetDataBufferByte = core.BNSetDataBufferByte
_BNSetDataBufferByte.restype = None
_BNSetDataBufferByte.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.c_ulonglong,
ctypes.c_ubyte,
]
# noinspection PyPep8Naming
def BNSetDataBufferByte(
buf: ctypes.POINTER(BNDataBuffer),
offset: int,
val: int
) -> None:
return _BNSetDataBufferByte(buf, offset, val)
# -------------------------------------------------------
# _BNSetDataBufferContents
_BNSetDataBufferContents = core.BNSetDataBufferContents
_BNSetDataBufferContents.restype = None
_BNSetDataBufferContents.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.c_void_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetDataBufferContents(
buf: ctypes.POINTER(BNDataBuffer),
data: Optional[ctypes.c_void_p],
len: int
) -> None:
return _BNSetDataBufferContents(buf, data, len)
# -------------------------------------------------------
# _BNSetDataBufferLength
_BNSetDataBufferLength = core.BNSetDataBufferLength
_BNSetDataBufferLength.restype = None
_BNSetDataBufferLength.argtypes = [
ctypes.POINTER(BNDataBuffer),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetDataBufferLength(
buf: ctypes.POINTER(BNDataBuffer),
len: int
) -> None:
return _BNSetDataBufferLength(buf, len)
# -------------------------------------------------------
# _BNSetDatabaseCurrentSnapshot
_BNSetDatabaseCurrentSnapshot = core.BNSetDatabaseCurrentSnapshot
_BNSetDatabaseCurrentSnapshot.restype = None
_BNSetDatabaseCurrentSnapshot.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNSetDatabaseCurrentSnapshot(
database: ctypes.POINTER(BNDatabase),
id: int
) -> None:
return _BNSetDatabaseCurrentSnapshot(database, id)
# -------------------------------------------------------
# _BNSetDebugInfo
_BNSetDebugInfo = core.BNSetDebugInfo
_BNSetDebugInfo.restype = None
_BNSetDebugInfo.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNDebugInfo),
]
# noinspection PyPep8Naming
def BNSetDebugInfo(
view: ctypes.POINTER(BNBinaryView),
newDebugInfo: ctypes.POINTER(BNDebugInfo)
) -> None:
return _BNSetDebugInfo(view, newDebugInfo)
# -------------------------------------------------------
# _BNSetDefaultArchitecture
_BNSetDefaultArchitecture = core.BNSetDefaultArchitecture
_BNSetDefaultArchitecture.restype = None
_BNSetDefaultArchitecture.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNSetDefaultArchitecture(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture)
) -> None:
return _BNSetDefaultArchitecture(view, arch)
# -------------------------------------------------------
# _BNSetDefaultPlatform
_BNSetDefaultPlatform = core.BNSetDefaultPlatform
_BNSetDefaultPlatform.restype = None
_BNSetDefaultPlatform.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNPlatform),
]
# noinspection PyPep8Naming
def BNSetDefaultPlatform(
view: ctypes.POINTER(BNBinaryView),
platform: ctypes.POINTER(BNPlatform)
) -> None:
return _BNSetDefaultPlatform(view, platform)
# -------------------------------------------------------
# _BNSetDisassemblyGutterWidth
_BNSetDisassemblyGutterWidth = core.BNSetDisassemblyGutterWidth
_BNSetDisassemblyGutterWidth.restype = None
_BNSetDisassemblyGutterWidth.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetDisassemblyGutterWidth(
settings: ctypes.POINTER(BNDisassemblySettings),
width: int
) -> None:
return _BNSetDisassemblyGutterWidth(settings, width)
# -------------------------------------------------------
# _BNSetDisassemblyMaximumSymbolWidth
_BNSetDisassemblyMaximumSymbolWidth = core.BNSetDisassemblyMaximumSymbolWidth
_BNSetDisassemblyMaximumSymbolWidth.restype = None
_BNSetDisassemblyMaximumSymbolWidth.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetDisassemblyMaximumSymbolWidth(
settings: ctypes.POINTER(BNDisassemblySettings),
width: int
) -> None:
return _BNSetDisassemblyMaximumSymbolWidth(settings, width)
# -------------------------------------------------------
# _BNSetDisassemblySettingsOption
_BNSetDisassemblySettingsOption = core.BNSetDisassemblySettingsOption
_BNSetDisassemblySettingsOption.restype = None
_BNSetDisassemblySettingsOption.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
DisassemblyOptionEnum,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSetDisassemblySettingsOption(
settings: ctypes.POINTER(BNDisassemblySettings),
option: DisassemblyOption,
state: bool
) -> None:
return _BNSetDisassemblySettingsOption(settings, option, state)
# -------------------------------------------------------
# _BNSetDisassemblyTextRendererArchitecture
_BNSetDisassemblyTextRendererArchitecture = core.BNSetDisassemblyTextRendererArchitecture
_BNSetDisassemblyTextRendererArchitecture.restype = None
_BNSetDisassemblyTextRendererArchitecture.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.POINTER(BNArchitecture),
]
# noinspection PyPep8Naming
def BNSetDisassemblyTextRendererArchitecture(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
arch: ctypes.POINTER(BNArchitecture)
) -> None:
return _BNSetDisassemblyTextRendererArchitecture(renderer, arch)
# -------------------------------------------------------
# _BNSetDisassemblyTextRendererBasicBlock
_BNSetDisassemblyTextRendererBasicBlock = core.BNSetDisassemblyTextRendererBasicBlock
_BNSetDisassemblyTextRendererBasicBlock.restype = None
_BNSetDisassemblyTextRendererBasicBlock.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNSetDisassemblyTextRendererBasicBlock(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
block: ctypes.POINTER(BNBasicBlock)
) -> None:
return _BNSetDisassemblyTextRendererBasicBlock(renderer, block)
# -------------------------------------------------------
# _BNSetDisassemblyTextRendererSettings
_BNSetDisassemblyTextRendererSettings = core.BNSetDisassemblyTextRendererSettings
_BNSetDisassemblyTextRendererSettings.restype = None
_BNSetDisassemblyTextRendererSettings.argtypes = [
ctypes.POINTER(BNDisassemblyTextRenderer),
ctypes.POINTER(BNDisassemblySettings),
]
# noinspection PyPep8Naming
def BNSetDisassemblyTextRendererSettings(
renderer: ctypes.POINTER(BNDisassemblyTextRenderer),
settings: ctypes.POINTER(BNDisassemblySettings)
) -> None:
return _BNSetDisassemblyTextRendererSettings(renderer, settings)
# -------------------------------------------------------
# _BNSetDisassemblyWidth
_BNSetDisassemblyWidth = core.BNSetDisassemblyWidth
_BNSetDisassemblyWidth.restype = None
_BNSetDisassemblyWidth.argtypes = [
ctypes.POINTER(BNDisassemblySettings),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetDisassemblyWidth(
settings: ctypes.POINTER(BNDisassemblySettings),
width: int
) -> None:
return _BNSetDisassemblyWidth(settings, width)
# -------------------------------------------------------
# _BNSetEnterpriseServerUrl
_BNSetEnterpriseServerUrl = core.BNSetEnterpriseServerUrl
_BNSetEnterpriseServerUrl.restype = ctypes.c_bool
_BNSetEnterpriseServerUrl.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetEnterpriseServerUrl(
url: Optional[str]
) -> bool:
return _BNSetEnterpriseServerUrl(cstr(url))
# -------------------------------------------------------
# _BNSetErrorForDownloadInstance
_BNSetErrorForDownloadInstance = core.BNSetErrorForDownloadInstance
_BNSetErrorForDownloadInstance.restype = None
_BNSetErrorForDownloadInstance.argtypes = [
ctypes.POINTER(BNDownloadInstance),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetErrorForDownloadInstance(
instance: ctypes.POINTER(BNDownloadInstance),
error: Optional[str]
) -> None:
return _BNSetErrorForDownloadInstance(instance, cstr(error))
# -------------------------------------------------------
# _BNSetFileMetadataNavigationHandler
_BNSetFileMetadataNavigationHandler = core.BNSetFileMetadataNavigationHandler
_BNSetFileMetadataNavigationHandler.restype = None
_BNSetFileMetadataNavigationHandler.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(BNNavigationHandler),
]
# noinspection PyPep8Naming
def BNSetFileMetadataNavigationHandler(
file: ctypes.POINTER(BNFileMetadata),
handler: ctypes.POINTER(BNNavigationHandler)
) -> None:
return _BNSetFileMetadataNavigationHandler(file, handler)
# -------------------------------------------------------
# _BNSetFilename
_BNSetFilename = core.BNSetFilename
_BNSetFilename.restype = None
_BNSetFilename.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetFilename(
file: ctypes.POINTER(BNFileMetadata),
name: Optional[str]
) -> None:
return _BNSetFilename(file, cstr(name))
# -------------------------------------------------------
# _BNSetFlowGraphBasicBlock
_BNSetFlowGraphBasicBlock = core.BNSetFlowGraphBasicBlock
_BNSetFlowGraphBasicBlock.restype = None
_BNSetFlowGraphBasicBlock.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNSetFlowGraphBasicBlock(
node: ctypes.POINTER(BNFlowGraphNode),
block: ctypes.POINTER(BNBasicBlock)
) -> None:
return _BNSetFlowGraphBasicBlock(node, block)
# -------------------------------------------------------
# _BNSetFlowGraphHighLevelILFunction
_BNSetFlowGraphHighLevelILFunction = core.BNSetFlowGraphHighLevelILFunction
_BNSetFlowGraphHighLevelILFunction.restype = None
_BNSetFlowGraphHighLevelILFunction.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNSetFlowGraphHighLevelILFunction(
graph: ctypes.POINTER(BNFlowGraph),
func: ctypes.POINTER(BNHighLevelILFunction)
) -> None:
return _BNSetFlowGraphHighLevelILFunction(graph, func)
# -------------------------------------------------------
# _BNSetFlowGraphLowLevelILFunction
_BNSetFlowGraphLowLevelILFunction = core.BNSetFlowGraphLowLevelILFunction
_BNSetFlowGraphLowLevelILFunction.restype = None
_BNSetFlowGraphLowLevelILFunction.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNSetFlowGraphLowLevelILFunction(
graph: ctypes.POINTER(BNFlowGraph),
func: ctypes.POINTER(BNLowLevelILFunction)
) -> None:
return _BNSetFlowGraphLowLevelILFunction(graph, func)
# -------------------------------------------------------
# _BNSetFlowGraphMediumLevelILFunction
_BNSetFlowGraphMediumLevelILFunction = core.BNSetFlowGraphMediumLevelILFunction
_BNSetFlowGraphMediumLevelILFunction.restype = None
_BNSetFlowGraphMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNSetFlowGraphMediumLevelILFunction(
graph: ctypes.POINTER(BNFlowGraph),
func: ctypes.POINTER(BNMediumLevelILFunction)
) -> None:
return _BNSetFlowGraphMediumLevelILFunction(graph, func)
# -------------------------------------------------------
# _BNSetFlowGraphNodeHighlight
_BNSetFlowGraphNodeHighlight = core.BNSetFlowGraphNodeHighlight
_BNSetFlowGraphNodeHighlight.restype = None
_BNSetFlowGraphNodeHighlight.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
BNHighlightColor,
]
# noinspection PyPep8Naming
def BNSetFlowGraphNodeHighlight(
node: ctypes.POINTER(BNFlowGraphNode),
color: BNHighlightColor
) -> None:
return _BNSetFlowGraphNodeHighlight(node, color)
# -------------------------------------------------------
# _BNSetFlowGraphNodeLines
_BNSetFlowGraphNodeLines = core.BNSetFlowGraphNodeLines
_BNSetFlowGraphNodeLines.restype = None
_BNSetFlowGraphNodeLines.argtypes = [
ctypes.POINTER(BNFlowGraphNode),
ctypes.POINTER(BNDisassemblyTextLine),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetFlowGraphNodeLines(
node: ctypes.POINTER(BNFlowGraphNode),
lines: ctypes.POINTER(BNDisassemblyTextLine),
count: int
) -> None:
return _BNSetFlowGraphNodeLines(node, lines, count)
# -------------------------------------------------------
# _BNSetFlowGraphNodeMargins
_BNSetFlowGraphNodeMargins = core.BNSetFlowGraphNodeMargins
_BNSetFlowGraphNodeMargins.restype = None
_BNSetFlowGraphNodeMargins.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.c_int,
ctypes.c_int,
]
# noinspection PyPep8Naming
def BNSetFlowGraphNodeMargins(
graph: ctypes.POINTER(BNFlowGraph),
horiz: int,
vert: int
) -> None:
return _BNSetFlowGraphNodeMargins(graph, horiz, vert)
# -------------------------------------------------------
# _BNSetFlowGraphOption
_BNSetFlowGraphOption = core.BNSetFlowGraphOption
_BNSetFlowGraphOption.restype = None
_BNSetFlowGraphOption.argtypes = [
ctypes.POINTER(BNFlowGraph),
FlowGraphOptionEnum,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSetFlowGraphOption(
graph: ctypes.POINTER(BNFlowGraph),
option: FlowGraphOption,
value: bool
) -> None:
return _BNSetFlowGraphOption(graph, option, value)
# -------------------------------------------------------
# _BNSetFunctionAnalysisSkipOverride
_BNSetFunctionAnalysisSkipOverride = core.BNSetFunctionAnalysisSkipOverride
_BNSetFunctionAnalysisSkipOverride.restype = None
_BNSetFunctionAnalysisSkipOverride.argtypes = [
ctypes.POINTER(BNFunction),
FunctionAnalysisSkipOverrideEnum,
]
# noinspection PyPep8Naming
def BNSetFunctionAnalysisSkipOverride(
func: ctypes.POINTER(BNFunction),
skip: FunctionAnalysisSkipOverride
) -> None:
return _BNSetFunctionAnalysisSkipOverride(func, skip)
# -------------------------------------------------------
# _BNSetFunctionAutoType
_BNSetFunctionAutoType = core.BNSetFunctionAutoType
_BNSetFunctionAutoType.restype = None
_BNSetFunctionAutoType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNSetFunctionAutoType(
func: ctypes.POINTER(BNFunction),
type: ctypes.POINTER(BNType)
) -> None:
return _BNSetFunctionAutoType(func, type)
# -------------------------------------------------------
# _BNSetFunctionComment
_BNSetFunctionComment = core.BNSetFunctionComment
_BNSetFunctionComment.restype = None
_BNSetFunctionComment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetFunctionComment(
func: ctypes.POINTER(BNFunction),
comment: Optional[str]
) -> None:
return _BNSetFunctionComment(func, cstr(comment))
# -------------------------------------------------------
# _BNSetFunctionForFlowGraph
_BNSetFunctionForFlowGraph = core.BNSetFunctionForFlowGraph
_BNSetFunctionForFlowGraph.restype = None
_BNSetFunctionForFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNSetFunctionForFlowGraph(
graph: ctypes.POINTER(BNFlowGraph),
func: ctypes.POINTER(BNFunction)
) -> None:
return _BNSetFunctionForFlowGraph(graph, func)
# -------------------------------------------------------
# _BNSetFunctionTypeBuilderCanReturn
_BNSetFunctionTypeBuilderCanReturn = core.BNSetFunctionTypeBuilderCanReturn
_BNSetFunctionTypeBuilderCanReturn.restype = None
_BNSetFunctionTypeBuilderCanReturn.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNSetFunctionTypeBuilderCanReturn(
type: ctypes.POINTER(BNTypeBuilder),
canReturn: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNSetFunctionTypeBuilderCanReturn(type, canReturn)
# -------------------------------------------------------
# _BNSetFunctionTypeBuilderParameters
_BNSetFunctionTypeBuilderParameters = core.BNSetFunctionTypeBuilderParameters
_BNSetFunctionTypeBuilderParameters.restype = None
_BNSetFunctionTypeBuilderParameters.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNFunctionParameter),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetFunctionTypeBuilderParameters(
type: ctypes.POINTER(BNTypeBuilder),
params: ctypes.POINTER(BNFunctionParameter),
paramCount: int
) -> None:
return _BNSetFunctionTypeBuilderParameters(type, params, paramCount)
# -------------------------------------------------------
# _BNSetFunctionUserType
_BNSetFunctionUserType = core.BNSetFunctionUserType
_BNSetFunctionUserType.restype = None
_BNSetFunctionUserType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNSetFunctionUserType(
func: ctypes.POINTER(BNFunction),
type: ctypes.POINTER(BNType)
) -> None:
return _BNSetFunctionUserType(func, type)
# -------------------------------------------------------
# _BNSetFunctionVariableDeadStoreElimination
_BNSetFunctionVariableDeadStoreElimination = core.BNSetFunctionVariableDeadStoreElimination
_BNSetFunctionVariableDeadStoreElimination.restype = None
_BNSetFunctionVariableDeadStoreElimination.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
DeadStoreEliminationEnum,
]
# noinspection PyPep8Naming
def BNSetFunctionVariableDeadStoreElimination(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable),
mode: DeadStoreElimination
) -> None:
return _BNSetFunctionVariableDeadStoreElimination(func, var, mode)
# -------------------------------------------------------
# _BNSetGlobalCommentForAddress
_BNSetGlobalCommentForAddress = core.BNSetGlobalCommentForAddress
_BNSetGlobalCommentForAddress.restype = None
_BNSetGlobalCommentForAddress.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetGlobalCommentForAddress(
view: ctypes.POINTER(BNBinaryView),
addr: int,
comment: Optional[str]
) -> None:
return _BNSetGlobalCommentForAddress(view, addr, cstr(comment))
# -------------------------------------------------------
# _BNSetHighLevelILExprAttributes
_BNSetHighLevelILExprAttributes = core.BNSetHighLevelILExprAttributes
_BNSetHighLevelILExprAttributes.restype = None
_BNSetHighLevelILExprAttributes.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNSetHighLevelILExprAttributes(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int,
attributes: int
) -> None:
return _BNSetHighLevelILExprAttributes(func, expr, attributes)
# -------------------------------------------------------
# _BNSetHighLevelILExprType
_BNSetHighLevelILExprType = core.BNSetHighLevelILExprType
_BNSetHighLevelILExprType.restype = None
_BNSetHighLevelILExprType.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeWithConfidence),
]
# noinspection PyPep8Naming
def BNSetHighLevelILExprType(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int,
type: ctypes.POINTER(BNTypeWithConfidence)
) -> None:
return _BNSetHighLevelILExprType(func, expr, type)
# -------------------------------------------------------
# _BNSetHighLevelILFunction
_BNSetHighLevelILFunction = core.BNSetHighLevelILFunction
_BNSetHighLevelILFunction.restype = None
_BNSetHighLevelILFunction.argtypes = [
ctypes.POINTER(BNAnalysisContext),
ctypes.POINTER(BNHighLevelILFunction),
]
# noinspection PyPep8Naming
def BNSetHighLevelILFunction(
analysisContext: ctypes.POINTER(BNAnalysisContext),
highLevelIL: ctypes.POINTER(BNHighLevelILFunction)
) -> None:
return _BNSetHighLevelILFunction(analysisContext, highLevelIL)
# -------------------------------------------------------
# _BNSetHighLevelILRootExpr
_BNSetHighLevelILRootExpr = core.BNSetHighLevelILRootExpr
_BNSetHighLevelILRootExpr.restype = None
_BNSetHighLevelILRootExpr.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetHighLevelILRootExpr(
func: ctypes.POINTER(BNHighLevelILFunction),
expr: int
) -> None:
return _BNSetHighLevelILRootExpr(func, expr)
# -------------------------------------------------------
# _BNSetIntegerConstantDisplayType
_BNSetIntegerConstantDisplayType = core.BNSetIntegerConstantDisplayType
_BNSetIntegerConstantDisplayType.restype = None
_BNSetIntegerConstantDisplayType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
IntegerDisplayTypeEnum,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetIntegerConstantDisplayType(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
instrAddr: int,
value: int,
operand: int,
type: IntegerDisplayType,
typeID: Optional[str]
) -> None:
return _BNSetIntegerConstantDisplayType(func, arch, instrAddr, value, operand, type, cstr(typeID))
# -------------------------------------------------------
# _BNSetIntegerTypeDisplayType
_BNSetIntegerTypeDisplayType = core.BNSetIntegerTypeDisplayType
_BNSetIntegerTypeDisplayType.restype = None
_BNSetIntegerTypeDisplayType.argtypes = [
ctypes.POINTER(BNTypeBuilder),
IntegerDisplayTypeEnum,
]
# noinspection PyPep8Naming
def BNSetIntegerTypeDisplayType(
type: ctypes.POINTER(BNTypeBuilder),
displayType: IntegerDisplayType
) -> None:
return _BNSetIntegerTypeDisplayType(type, displayType)
# -------------------------------------------------------
# _BNSetKeyValueStoreBuffer
_BNSetKeyValueStoreBuffer = core.BNSetKeyValueStoreBuffer
_BNSetKeyValueStoreBuffer.restype = ctypes.c_bool
_BNSetKeyValueStoreBuffer.argtypes = [
ctypes.POINTER(BNKeyValueStore),
ctypes.c_char_p,
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNSetKeyValueStoreBuffer(
store: ctypes.POINTER(BNKeyValueStore),
name: Optional[str],
value: ctypes.POINTER(BNDataBuffer)
) -> bool:
return _BNSetKeyValueStoreBuffer(store, cstr(name), value)
# -------------------------------------------------------
# _BNSetKeyValueStoreValue
_BNSetKeyValueStoreValue = core.BNSetKeyValueStoreValue
_BNSetKeyValueStoreValue.restype = ctypes.c_bool
_BNSetKeyValueStoreValue.argtypes = [
ctypes.POINTER(BNKeyValueStore),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetKeyValueStoreValue(
store: ctypes.POINTER(BNKeyValueStore),
name: Optional[str],
value: Optional[str]
) -> bool:
return _BNSetKeyValueStoreValue(store, cstr(name), cstr(value))
# -------------------------------------------------------
# _BNSetLicense
_BNSetLicense = core.BNSetLicense
_BNSetLicense.restype = None
_BNSetLicense.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetLicense(
licenseData: Optional[str]
) -> None:
return _BNSetLicense(cstr(licenseData))
# -------------------------------------------------------
# _BNSetLiftedILFunction
_BNSetLiftedILFunction = core.BNSetLiftedILFunction
_BNSetLiftedILFunction.restype = None
_BNSetLiftedILFunction.argtypes = [
ctypes.POINTER(BNAnalysisContext),
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNSetLiftedILFunction(
analysisContext: ctypes.POINTER(BNAnalysisContext),
liftedIL: ctypes.POINTER(BNLowLevelILFunction)
) -> None:
return _BNSetLiftedILFunction(analysisContext, liftedIL)
# -------------------------------------------------------
# _BNSetLowLevelILExprAttributes
_BNSetLowLevelILExprAttributes = core.BNSetLowLevelILExprAttributes
_BNSetLowLevelILExprAttributes.restype = None
_BNSetLowLevelILExprAttributes.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNSetLowLevelILExprAttributes(
func: ctypes.POINTER(BNLowLevelILFunction),
expr: int,
attributes: int
) -> None:
return _BNSetLowLevelILExprAttributes(func, expr, attributes)
# -------------------------------------------------------
# _BNSetLowLevelILFunction
_BNSetLowLevelILFunction = core.BNSetLowLevelILFunction
_BNSetLowLevelILFunction.restype = None
_BNSetLowLevelILFunction.argtypes = [
ctypes.POINTER(BNAnalysisContext),
ctypes.POINTER(BNLowLevelILFunction),
]
# noinspection PyPep8Naming
def BNSetLowLevelILFunction(
analysisContext: ctypes.POINTER(BNAnalysisContext),
lowLevelIL: ctypes.POINTER(BNLowLevelILFunction)
) -> None:
return _BNSetLowLevelILFunction(analysisContext, lowLevelIL)
# -------------------------------------------------------
# _BNSetMaxFunctionSizeForAnalysis
_BNSetMaxFunctionSizeForAnalysis = core.BNSetMaxFunctionSizeForAnalysis
_BNSetMaxFunctionSizeForAnalysis.restype = None
_BNSetMaxFunctionSizeForAnalysis.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetMaxFunctionSizeForAnalysis(
view: ctypes.POINTER(BNBinaryView),
size: int
) -> None:
return _BNSetMaxFunctionSizeForAnalysis(view, size)
# -------------------------------------------------------
# _BNSetMediumLevelILExprAttributes
_BNSetMediumLevelILExprAttributes = core.BNSetMediumLevelILExprAttributes
_BNSetMediumLevelILExprAttributes.restype = None
_BNSetMediumLevelILExprAttributes.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNSetMediumLevelILExprAttributes(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int,
attributes: int
) -> None:
return _BNSetMediumLevelILExprAttributes(func, expr, attributes)
# -------------------------------------------------------
# _BNSetMediumLevelILExprType
_BNSetMediumLevelILExprType = core.BNSetMediumLevelILExprType
_BNSetMediumLevelILExprType.restype = None
_BNSetMediumLevelILExprType.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeWithConfidence),
]
# noinspection PyPep8Naming
def BNSetMediumLevelILExprType(
func: ctypes.POINTER(BNMediumLevelILFunction),
expr: int,
type: ctypes.POINTER(BNTypeWithConfidence)
) -> None:
return _BNSetMediumLevelILExprType(func, expr, type)
# -------------------------------------------------------
# _BNSetMediumLevelILFunction
_BNSetMediumLevelILFunction = core.BNSetMediumLevelILFunction
_BNSetMediumLevelILFunction.restype = None
_BNSetMediumLevelILFunction.argtypes = [
ctypes.POINTER(BNAnalysisContext),
ctypes.POINTER(BNMediumLevelILFunction),
]
# noinspection PyPep8Naming
def BNSetMediumLevelILFunction(
analysisContext: ctypes.POINTER(BNAnalysisContext),
mediumLevelIL: ctypes.POINTER(BNMediumLevelILFunction)
) -> None:
return _BNSetMediumLevelILFunction(analysisContext, mediumLevelIL)
# -------------------------------------------------------
# _BNSetNamedTypeReferenceBuilderName
_BNSetNamedTypeReferenceBuilderName = core.BNSetNamedTypeReferenceBuilderName
_BNSetNamedTypeReferenceBuilderName.restype = None
_BNSetNamedTypeReferenceBuilderName.argtypes = [
ctypes.POINTER(BNNamedTypeReferenceBuilder),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNSetNamedTypeReferenceBuilderName(
s: ctypes.POINTER(BNNamedTypeReferenceBuilder),
name: ctypes.POINTER(BNQualifiedName)
) -> None:
return _BNSetNamedTypeReferenceBuilderName(s, name)
# -------------------------------------------------------
# _BNSetNamedTypeReferenceBuilderTypeClass
_BNSetNamedTypeReferenceBuilderTypeClass = core.BNSetNamedTypeReferenceBuilderTypeClass
_BNSetNamedTypeReferenceBuilderTypeClass.restype = None
_BNSetNamedTypeReferenceBuilderTypeClass.argtypes = [
ctypes.POINTER(BNNamedTypeReferenceBuilder),
NamedTypeReferenceClassEnum,
]
# noinspection PyPep8Naming
def BNSetNamedTypeReferenceBuilderTypeClass(
s: ctypes.POINTER(BNNamedTypeReferenceBuilder),
type: NamedTypeReferenceClass
) -> None:
return _BNSetNamedTypeReferenceBuilderTypeClass(s, type)
# -------------------------------------------------------
# _BNSetNamedTypeReferenceBuilderTypeId
_BNSetNamedTypeReferenceBuilderTypeId = core.BNSetNamedTypeReferenceBuilderTypeId
_BNSetNamedTypeReferenceBuilderTypeId.restype = None
_BNSetNamedTypeReferenceBuilderTypeId.argtypes = [
ctypes.POINTER(BNNamedTypeReferenceBuilder),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetNamedTypeReferenceBuilderTypeId(
s: ctypes.POINTER(BNNamedTypeReferenceBuilder),
id: Optional[str]
) -> None:
return _BNSetNamedTypeReferenceBuilderTypeId(s, cstr(id))
# -------------------------------------------------------
# _BNSetNewAutoFunctionAnalysisSuppressed
_BNSetNewAutoFunctionAnalysisSuppressed = core.BNSetNewAutoFunctionAnalysisSuppressed
_BNSetNewAutoFunctionAnalysisSuppressed.restype = None
_BNSetNewAutoFunctionAnalysisSuppressed.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSetNewAutoFunctionAnalysisSuppressed(
view: ctypes.POINTER(BNBinaryView),
suppress: bool
) -> None:
return _BNSetNewAutoFunctionAnalysisSuppressed(view, suppress)
# -------------------------------------------------------
# _BNSetOriginalBase
_BNSetOriginalBase = core.BNSetOriginalBase
_BNSetOriginalBase.restype = None
_BNSetOriginalBase.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetOriginalBase(
view: ctypes.POINTER(BNBinaryView),
base: int
) -> None:
return _BNSetOriginalBase(view, base)
# -------------------------------------------------------
# _BNSetOriginalFilename
_BNSetOriginalFilename = core.BNSetOriginalFilename
_BNSetOriginalFilename.restype = None
_BNSetOriginalFilename.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetOriginalFilename(
file: ctypes.POINTER(BNFileMetadata),
name: Optional[str]
) -> None:
return _BNSetOriginalFilename(file, cstr(name))
# -------------------------------------------------------
# _BNSetParametersForAnalysis
_BNSetParametersForAnalysis = core.BNSetParametersForAnalysis
_BNSetParametersForAnalysis.restype = None
_BNSetParametersForAnalysis.argtypes = [
ctypes.POINTER(BNBinaryView),
BNAnalysisParameters,
]
# noinspection PyPep8Naming
def BNSetParametersForAnalysis(
view: ctypes.POINTER(BNBinaryView),
params: BNAnalysisParameters
) -> None:
return _BNSetParametersForAnalysis(view, params)
# -------------------------------------------------------
# _BNSetPlatformSystemCallConvention
_BNSetPlatformSystemCallConvention = core.BNSetPlatformSystemCallConvention
_BNSetPlatformSystemCallConvention.restype = None
_BNSetPlatformSystemCallConvention.argtypes = [
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNCallingConvention),
]
# noinspection PyPep8Naming
def BNSetPlatformSystemCallConvention(
platform: ctypes.POINTER(BNPlatform),
cc: ctypes.POINTER(BNCallingConvention)
) -> None:
return _BNSetPlatformSystemCallConvention(platform, cc)
# -------------------------------------------------------
# _BNSetProjectFile
_BNSetProjectFile = core.BNSetProjectFile
_BNSetProjectFile.restype = None
_BNSetProjectFile.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.POINTER(BNProjectFile),
]
# noinspection PyPep8Naming
def BNSetProjectFile(
file: ctypes.POINTER(BNFileMetadata),
pfile: ctypes.POINTER(BNProjectFile)
) -> None:
return _BNSetProjectFile(file, pfile)
# -------------------------------------------------------
# _BNSetSaveSettingsName
_BNSetSaveSettingsName = core.BNSetSaveSettingsName
_BNSetSaveSettingsName.restype = None
_BNSetSaveSettingsName.argtypes = [
ctypes.POINTER(BNSaveSettings),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetSaveSettingsName(
settings: ctypes.POINTER(BNSaveSettings),
name: Optional[str]
) -> None:
return _BNSetSaveSettingsName(settings, cstr(name))
# -------------------------------------------------------
# _BNSetSaveSettingsOption
_BNSetSaveSettingsOption = core.BNSetSaveSettingsOption
_BNSetSaveSettingsOption.restype = None
_BNSetSaveSettingsOption.argtypes = [
ctypes.POINTER(BNSaveSettings),
SaveOptionEnum,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSetSaveSettingsOption(
settings: ctypes.POINTER(BNSaveSettings),
option: SaveOption,
state: bool
) -> None:
return _BNSetSaveSettingsOption(settings, option, state)
# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentAddress
_BNSetScriptingInstanceCurrentAddress = core.BNSetScriptingInstanceCurrentAddress
_BNSetScriptingInstanceCurrentAddress.restype = None
_BNSetScriptingInstanceCurrentAddress.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentAddress(
instance: ctypes.POINTER(BNScriptingInstance),
addr: int
) -> None:
return _BNSetScriptingInstanceCurrentAddress(instance, addr)
# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentBasicBlock
_BNSetScriptingInstanceCurrentBasicBlock = core.BNSetScriptingInstanceCurrentBasicBlock
_BNSetScriptingInstanceCurrentBasicBlock.restype = None
_BNSetScriptingInstanceCurrentBasicBlock.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.POINTER(BNBasicBlock),
]
# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentBasicBlock(
instance: ctypes.POINTER(BNScriptingInstance),
block: ctypes.POINTER(BNBasicBlock)
) -> None:
return _BNSetScriptingInstanceCurrentBasicBlock(instance, block)
# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentBinaryView
_BNSetScriptingInstanceCurrentBinaryView = core.BNSetScriptingInstanceCurrentBinaryView
_BNSetScriptingInstanceCurrentBinaryView.restype = None
_BNSetScriptingInstanceCurrentBinaryView.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentBinaryView(
instance: ctypes.POINTER(BNScriptingInstance),
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNSetScriptingInstanceCurrentBinaryView(instance, view)
# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentFunction
_BNSetScriptingInstanceCurrentFunction = core.BNSetScriptingInstanceCurrentFunction
_BNSetScriptingInstanceCurrentFunction.restype = None
_BNSetScriptingInstanceCurrentFunction.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentFunction(
instance: ctypes.POINTER(BNScriptingInstance),
func: ctypes.POINTER(BNFunction)
) -> None:
return _BNSetScriptingInstanceCurrentFunction(instance, func)
# -------------------------------------------------------
# _BNSetScriptingInstanceCurrentSelection
_BNSetScriptingInstanceCurrentSelection = core.BNSetScriptingInstanceCurrentSelection
_BNSetScriptingInstanceCurrentSelection.restype = None
_BNSetScriptingInstanceCurrentSelection.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetScriptingInstanceCurrentSelection(
instance: ctypes.POINTER(BNScriptingInstance),
begin: int,
end: int
) -> None:
return _BNSetScriptingInstanceCurrentSelection(instance, begin, end)
# -------------------------------------------------------
# _BNSetScriptingInstanceDelimiters
_BNSetScriptingInstanceDelimiters = core.BNSetScriptingInstanceDelimiters
_BNSetScriptingInstanceDelimiters.restype = None
_BNSetScriptingInstanceDelimiters.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetScriptingInstanceDelimiters(
instance: ctypes.POINTER(BNScriptingInstance),
delimiters: Optional[str]
) -> None:
return _BNSetScriptingInstanceDelimiters(instance, cstr(delimiters))
# -------------------------------------------------------
# _BNSetSnapshotName
_BNSetSnapshotName = core.BNSetSnapshotName
_BNSetSnapshotName.restype = None
_BNSetSnapshotName.argtypes = [
ctypes.POINTER(BNSnapshot),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetSnapshotName(
snapshot: ctypes.POINTER(BNSnapshot),
name: Optional[str]
) -> None:
return _BNSetSnapshotName(snapshot, cstr(name))
# -------------------------------------------------------
# _BNSetStructureBuilderAlignment
_BNSetStructureBuilderAlignment = core.BNSetStructureBuilderAlignment
_BNSetStructureBuilderAlignment.restype = None
_BNSetStructureBuilderAlignment.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetStructureBuilderAlignment(
s: ctypes.POINTER(BNStructureBuilder),
align: int
) -> None:
return _BNSetStructureBuilderAlignment(s, align)
# -------------------------------------------------------
# _BNSetStructureBuilderPacked
_BNSetStructureBuilderPacked = core.BNSetStructureBuilderPacked
_BNSetStructureBuilderPacked.restype = None
_BNSetStructureBuilderPacked.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSetStructureBuilderPacked(
s: ctypes.POINTER(BNStructureBuilder),
packed: bool
) -> None:
return _BNSetStructureBuilderPacked(s, packed)
# -------------------------------------------------------
# _BNSetStructureBuilderPointerOffset
_BNSetStructureBuilderPointerOffset = core.BNSetStructureBuilderPointerOffset
_BNSetStructureBuilderPointerOffset.restype = None
_BNSetStructureBuilderPointerOffset.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNSetStructureBuilderPointerOffset(
s: ctypes.POINTER(BNStructureBuilder),
offset: int
) -> None:
return _BNSetStructureBuilderPointerOffset(s, offset)
# -------------------------------------------------------
# _BNSetStructureBuilderPropagatesDataVariableReferences
_BNSetStructureBuilderPropagatesDataVariableReferences = core.BNSetStructureBuilderPropagatesDataVariableReferences
_BNSetStructureBuilderPropagatesDataVariableReferences.restype = None
_BNSetStructureBuilderPropagatesDataVariableReferences.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSetStructureBuilderPropagatesDataVariableReferences(
s: ctypes.POINTER(BNStructureBuilder),
value: bool
) -> None:
return _BNSetStructureBuilderPropagatesDataVariableReferences(s, value)
# -------------------------------------------------------
# _BNSetStructureBuilderType
_BNSetStructureBuilderType = core.BNSetStructureBuilderType
_BNSetStructureBuilderType.restype = None
_BNSetStructureBuilderType.argtypes = [
ctypes.POINTER(BNStructureBuilder),
StructureVariantEnum,
]
# noinspection PyPep8Naming
def BNSetStructureBuilderType(
s: ctypes.POINTER(BNStructureBuilder),
type: StructureVariant
) -> None:
return _BNSetStructureBuilderType(s, type)
# -------------------------------------------------------
# _BNSetStructureBuilderWidth
_BNSetStructureBuilderWidth = core.BNSetStructureBuilderWidth
_BNSetStructureBuilderWidth.restype = None
_BNSetStructureBuilderWidth.argtypes = [
ctypes.POINTER(BNStructureBuilder),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetStructureBuilderWidth(
s: ctypes.POINTER(BNStructureBuilder),
width: int
) -> None:
return _BNSetStructureBuilderWidth(s, width)
# -------------------------------------------------------
# _BNSetTypeArchiveCurrentSnapshot
_BNSetTypeArchiveCurrentSnapshot = core.BNSetTypeArchiveCurrentSnapshot
_BNSetTypeArchiveCurrentSnapshot.restype = None
_BNSetTypeArchiveCurrentSnapshot.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetTypeArchiveCurrentSnapshot(
archive: ctypes.POINTER(BNTypeArchive),
id: Optional[str]
) -> None:
return _BNSetTypeArchiveCurrentSnapshot(archive, cstr(id))
# -------------------------------------------------------
# _BNSetTypeBuilderNamedTypeReference
_BNSetTypeBuilderNamedTypeReference = core.BNSetTypeBuilderNamedTypeReference
_BNSetTypeBuilderNamedTypeReference.restype = None
_BNSetTypeBuilderNamedTypeReference.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNNamedTypeReference),
]
# noinspection PyPep8Naming
def BNSetTypeBuilderNamedTypeReference(
type: ctypes.POINTER(BNTypeBuilder),
ntr: ctypes.POINTER(BNNamedTypeReference)
) -> None:
return _BNSetTypeBuilderNamedTypeReference(type, ntr)
# -------------------------------------------------------
# _BNSetTypeBuilderOffset
_BNSetTypeBuilderOffset = core.BNSetTypeBuilderOffset
_BNSetTypeBuilderOffset.restype = None
_BNSetTypeBuilderOffset.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetTypeBuilderOffset(
type: ctypes.POINTER(BNTypeBuilder),
offset: int
) -> None:
return _BNSetTypeBuilderOffset(type, offset)
# -------------------------------------------------------
# _BNSetTypeBuilderPure
_BNSetTypeBuilderPure = core.BNSetTypeBuilderPure
_BNSetTypeBuilderPure.restype = None
_BNSetTypeBuilderPure.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNSetTypeBuilderPure(
type: ctypes.POINTER(BNTypeBuilder),
pure: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNSetTypeBuilderPure(type, pure)
# -------------------------------------------------------
# _BNSetTypeLibraryDependencyName
_BNSetTypeLibraryDependencyName = core.BNSetTypeLibraryDependencyName
_BNSetTypeLibraryDependencyName.restype = None
_BNSetTypeLibraryDependencyName.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetTypeLibraryDependencyName(
lib: ctypes.POINTER(BNTypeLibrary),
name: Optional[str]
) -> None:
return _BNSetTypeLibraryDependencyName(lib, cstr(name))
# -------------------------------------------------------
# _BNSetTypeLibraryGuid
_BNSetTypeLibraryGuid = core.BNSetTypeLibraryGuid
_BNSetTypeLibraryGuid.restype = None
_BNSetTypeLibraryGuid.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetTypeLibraryGuid(
lib: ctypes.POINTER(BNTypeLibrary),
name: Optional[str]
) -> None:
return _BNSetTypeLibraryGuid(lib, cstr(name))
# -------------------------------------------------------
# _BNSetTypeLibraryName
_BNSetTypeLibraryName = core.BNSetTypeLibraryName
_BNSetTypeLibraryName.restype = None
_BNSetTypeLibraryName.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetTypeLibraryName(
lib: ctypes.POINTER(BNTypeLibrary),
name: Optional[str]
) -> None:
return _BNSetTypeLibraryName(lib, cstr(name))
# -------------------------------------------------------
# _BNSetUserBasicBlockHighlight
_BNSetUserBasicBlockHighlight = core.BNSetUserBasicBlockHighlight
_BNSetUserBasicBlockHighlight.restype = None
_BNSetUserBasicBlockHighlight.argtypes = [
ctypes.POINTER(BNBasicBlock),
BNHighlightColor,
]
# noinspection PyPep8Naming
def BNSetUserBasicBlockHighlight(
block: ctypes.POINTER(BNBasicBlock),
color: BNHighlightColor
) -> None:
return _BNSetUserBasicBlockHighlight(block, color)
# -------------------------------------------------------
# _BNSetUserCallRegisterStackAdjustment
_BNSetUserCallRegisterStackAdjustment = core.BNSetUserCallRegisterStackAdjustment
_BNSetUserCallRegisterStackAdjustment.restype = None
_BNSetUserCallRegisterStackAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNRegisterStackAdjustment),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetUserCallRegisterStackAdjustment(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
adjust: ctypes.POINTER(BNRegisterStackAdjustment),
count: int
) -> None:
return _BNSetUserCallRegisterStackAdjustment(func, arch, addr, adjust, count)
# -------------------------------------------------------
# _BNSetUserCallRegisterStackAdjustmentForRegisterStack
_BNSetUserCallRegisterStackAdjustmentForRegisterStack = core.BNSetUserCallRegisterStackAdjustmentForRegisterStack
_BNSetUserCallRegisterStackAdjustmentForRegisterStack.restype = None
_BNSetUserCallRegisterStackAdjustmentForRegisterStack.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_uint,
ctypes.c_int,
ctypes.c_ubyte,
]
# noinspection PyPep8Naming
def BNSetUserCallRegisterStackAdjustmentForRegisterStack(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
regStack: int,
adjust: int,
confidence: int
) -> None:
return _BNSetUserCallRegisterStackAdjustmentForRegisterStack(func, arch, addr, regStack, adjust, confidence)
# -------------------------------------------------------
# _BNSetUserCallStackAdjustment
_BNSetUserCallStackAdjustment = core.BNSetUserCallStackAdjustment
_BNSetUserCallStackAdjustment.restype = None
_BNSetUserCallStackAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_longlong,
ctypes.c_ubyte,
]
# noinspection PyPep8Naming
def BNSetUserCallStackAdjustment(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
adjust: int,
confidence: int
) -> None:
return _BNSetUserCallStackAdjustment(func, arch, addr, adjust, confidence)
# -------------------------------------------------------
# _BNSetUserCallTypeAdjustment
_BNSetUserCallTypeAdjustment = core.BNSetUserCallTypeAdjustment
_BNSetUserCallTypeAdjustment.restype = None
_BNSetUserCallTypeAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNTypeWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserCallTypeAdjustment(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
type: ctypes.POINTER(BNTypeWithConfidence)
) -> None:
return _BNSetUserCallTypeAdjustment(func, arch, addr, type)
# -------------------------------------------------------
# _BNSetUserFunctionCallingConvention
_BNSetUserFunctionCallingConvention = core.BNSetUserFunctionCallingConvention
_BNSetUserFunctionCallingConvention.restype = None
_BNSetUserFunctionCallingConvention.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNCallingConventionWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserFunctionCallingConvention(
func: ctypes.POINTER(BNFunction),
convention: ctypes.POINTER(BNCallingConventionWithConfidence)
) -> None:
return _BNSetUserFunctionCallingConvention(func, convention)
# -------------------------------------------------------
# _BNSetUserFunctionCanReturn
_BNSetUserFunctionCanReturn = core.BNSetUserFunctionCanReturn
_BNSetUserFunctionCanReturn.restype = None
_BNSetUserFunctionCanReturn.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserFunctionCanReturn(
func: ctypes.POINTER(BNFunction),
returns: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNSetUserFunctionCanReturn(func, returns)
# -------------------------------------------------------
# _BNSetUserFunctionClobberedRegisters
_BNSetUserFunctionClobberedRegisters = core.BNSetUserFunctionClobberedRegisters
_BNSetUserFunctionClobberedRegisters.restype = None
_BNSetUserFunctionClobberedRegisters.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNRegisterSetWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserFunctionClobberedRegisters(
func: ctypes.POINTER(BNFunction),
regs: ctypes.POINTER(BNRegisterSetWithConfidence)
) -> None:
return _BNSetUserFunctionClobberedRegisters(func, regs)
# -------------------------------------------------------
# _BNSetUserFunctionHasVariableArguments
_BNSetUserFunctionHasVariableArguments = core.BNSetUserFunctionHasVariableArguments
_BNSetUserFunctionHasVariableArguments.restype = None
_BNSetUserFunctionHasVariableArguments.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserFunctionHasVariableArguments(
func: ctypes.POINTER(BNFunction),
varArgs: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNSetUserFunctionHasVariableArguments(func, varArgs)
# -------------------------------------------------------
# _BNSetUserFunctionInlinedDuringAnalysis
_BNSetUserFunctionInlinedDuringAnalysis = core.BNSetUserFunctionInlinedDuringAnalysis
_BNSetUserFunctionInlinedDuringAnalysis.restype = None
_BNSetUserFunctionInlinedDuringAnalysis.argtypes = [
ctypes.POINTER(BNFunction),
BNBoolWithConfidence,
]
# noinspection PyPep8Naming
def BNSetUserFunctionInlinedDuringAnalysis(
func: ctypes.POINTER(BNFunction),
inlined: BNBoolWithConfidence
) -> None:
return _BNSetUserFunctionInlinedDuringAnalysis(func, inlined)
# -------------------------------------------------------
# _BNSetUserFunctionParameterVariables
_BNSetUserFunctionParameterVariables = core.BNSetUserFunctionParameterVariables
_BNSetUserFunctionParameterVariables.restype = None
_BNSetUserFunctionParameterVariables.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNParameterVariablesWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserFunctionParameterVariables(
func: ctypes.POINTER(BNFunction),
vars: ctypes.POINTER(BNParameterVariablesWithConfidence)
) -> None:
return _BNSetUserFunctionParameterVariables(func, vars)
# -------------------------------------------------------
# _BNSetUserFunctionPure
_BNSetUserFunctionPure = core.BNSetUserFunctionPure
_BNSetUserFunctionPure.restype = None
_BNSetUserFunctionPure.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserFunctionPure(
func: ctypes.POINTER(BNFunction),
pure: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNSetUserFunctionPure(func, pure)
# -------------------------------------------------------
# _BNSetUserFunctionRegisterStackAdjustments
_BNSetUserFunctionRegisterStackAdjustments = core.BNSetUserFunctionRegisterStackAdjustments
_BNSetUserFunctionRegisterStackAdjustments.restype = None
_BNSetUserFunctionRegisterStackAdjustments.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNRegisterStackAdjustment),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetUserFunctionRegisterStackAdjustments(
func: ctypes.POINTER(BNFunction),
adjustments: ctypes.POINTER(BNRegisterStackAdjustment),
count: int
) -> None:
return _BNSetUserFunctionRegisterStackAdjustments(func, adjustments, count)
# -------------------------------------------------------
# _BNSetUserFunctionReturnRegisters
_BNSetUserFunctionReturnRegisters = core.BNSetUserFunctionReturnRegisters
_BNSetUserFunctionReturnRegisters.restype = None
_BNSetUserFunctionReturnRegisters.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNRegisterSetWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserFunctionReturnRegisters(
func: ctypes.POINTER(BNFunction),
regs: ctypes.POINTER(BNRegisterSetWithConfidence)
) -> None:
return _BNSetUserFunctionReturnRegisters(func, regs)
# -------------------------------------------------------
# _BNSetUserFunctionReturnType
_BNSetUserFunctionReturnType = core.BNSetUserFunctionReturnType
_BNSetUserFunctionReturnType.restype = None
_BNSetUserFunctionReturnType.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNTypeWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserFunctionReturnType(
func: ctypes.POINTER(BNFunction),
type: ctypes.POINTER(BNTypeWithConfidence)
) -> None:
return _BNSetUserFunctionReturnType(func, type)
# -------------------------------------------------------
# _BNSetUserFunctionStackAdjustment
_BNSetUserFunctionStackAdjustment = core.BNSetUserFunctionStackAdjustment
_BNSetUserFunctionStackAdjustment.restype = None
_BNSetUserFunctionStackAdjustment.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNOffsetWithConfidence),
]
# noinspection PyPep8Naming
def BNSetUserFunctionStackAdjustment(
func: ctypes.POINTER(BNFunction),
stackAdjust: ctypes.POINTER(BNOffsetWithConfidence)
) -> None:
return _BNSetUserFunctionStackAdjustment(func, stackAdjust)
# -------------------------------------------------------
# _BNSetUserGotoLabelName
_BNSetUserGotoLabelName = core.BNSetUserGotoLabelName
_BNSetUserGotoLabelName.restype = None
_BNSetUserGotoLabelName.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.c_ulonglong,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSetUserGotoLabelName(
func: ctypes.POINTER(BNFunction),
labelId: int,
name: Optional[str]
) -> None:
return _BNSetUserGotoLabelName(func, labelId, cstr(name))
# -------------------------------------------------------
# _BNSetUserIndirectBranches
_BNSetUserIndirectBranches = core.BNSetUserIndirectBranches
_BNSetUserIndirectBranches.restype = None
_BNSetUserIndirectBranches.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.POINTER(BNArchitectureAndAddress),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetUserIndirectBranches(
func: ctypes.POINTER(BNFunction),
sourceArch: ctypes.POINTER(BNArchitecture),
source: int,
branches: ctypes.POINTER(BNArchitectureAndAddress),
count: int
) -> None:
return _BNSetUserIndirectBranches(func, sourceArch, source, branches, count)
# -------------------------------------------------------
# _BNSetUserInstructionHighlight
_BNSetUserInstructionHighlight = core.BNSetUserInstructionHighlight
_BNSetUserInstructionHighlight.restype = None
_BNSetUserInstructionHighlight.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
BNHighlightColor,
]
# noinspection PyPep8Naming
def BNSetUserInstructionHighlight(
func: ctypes.POINTER(BNFunction),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
color: BNHighlightColor
) -> None:
return _BNSetUserInstructionHighlight(func, arch, addr, color)
# -------------------------------------------------------
# _BNSetUserVariableValue
_BNSetUserVariableValue = core.BNSetUserVariableValue
_BNSetUserVariableValue.restype = None
_BNSetUserVariableValue.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(BNArchitectureAndAddress),
ctypes.POINTER(BNPossibleValueSet),
]
# noinspection PyPep8Naming
def BNSetUserVariableValue(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable),
defSite: ctypes.POINTER(BNArchitectureAndAddress),
value: ctypes.POINTER(BNPossibleValueSet)
) -> None:
return _BNSetUserVariableValue(func, var, defSite, value)
# -------------------------------------------------------
# _BNSetViewForFlowGraph
_BNSetViewForFlowGraph = core.BNSetViewForFlowGraph
_BNSetViewForFlowGraph.restype = None
_BNSetViewForFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNSetViewForFlowGraph(
graph: ctypes.POINTER(BNFlowGraph),
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNSetViewForFlowGraph(graph, view)
# -------------------------------------------------------
# _BNSetWorkerThreadCount
_BNSetWorkerThreadCount = core.BNSetWorkerThreadCount
_BNSetWorkerThreadCount.restype = None
_BNSetWorkerThreadCount.argtypes = [
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSetWorkerThreadCount(
count: int
) -> None:
return _BNSetWorkerThreadCount(count)
# -------------------------------------------------------
# _BNSettingsContains
_BNSettingsContains = core.BNSettingsContains
_BNSettingsContains.restype = ctypes.c_bool
_BNSettingsContains.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSettingsContains(
settings: ctypes.POINTER(BNSettings),
key: Optional[str]
) -> bool:
return _BNSettingsContains(settings, cstr(key))
# -------------------------------------------------------
# _BNSettingsDeserializeSchema
_BNSettingsDeserializeSchema = core.BNSettingsDeserializeSchema
_BNSettingsDeserializeSchema.restype = ctypes.c_bool
_BNSettingsDeserializeSchema.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
SettingsScopeEnum,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSettingsDeserializeSchema(
settings: ctypes.POINTER(BNSettings),
schema: Optional[str],
scope: SettingsScope,
merge: bool
) -> bool:
return _BNSettingsDeserializeSchema(settings, cstr(schema), scope, merge)
# -------------------------------------------------------
# _BNSettingsGetBool
_BNSettingsGetBool = core.BNSettingsGetBool
_BNSettingsGetBool.restype = ctypes.c_bool
_BNSettingsGetBool.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(SettingsScopeEnum),
]
# noinspection PyPep8Naming
def BNSettingsGetBool(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
view: ctypes.POINTER(BNBinaryView),
scope: ctypes.POINTER(SettingsScopeEnum)
) -> bool:
return _BNSettingsGetBool(settings, cstr(key), view, scope)
# -------------------------------------------------------
# _BNSettingsGetDouble
_BNSettingsGetDouble = core.BNSettingsGetDouble
_BNSettingsGetDouble.restype = ctypes.c_double
_BNSettingsGetDouble.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(SettingsScopeEnum),
]
# noinspection PyPep8Naming
def BNSettingsGetDouble(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
view: ctypes.POINTER(BNBinaryView),
scope: ctypes.POINTER(SettingsScopeEnum)
) -> float:
return _BNSettingsGetDouble(settings, cstr(key), view, scope)
# -------------------------------------------------------
# _BNSettingsGetInt64
_BNSettingsGetInt64 = core.BNSettingsGetInt64
_BNSettingsGetInt64.restype = ctypes.c_longlong
_BNSettingsGetInt64.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(SettingsScopeEnum),
]
# noinspection PyPep8Naming
def BNSettingsGetInt64(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
view: ctypes.POINTER(BNBinaryView),
scope: ctypes.POINTER(SettingsScopeEnum)
) -> int:
return _BNSettingsGetInt64(settings, cstr(key), view, scope)
# -------------------------------------------------------
# _BNSettingsGetJson
_BNSettingsGetJson = core.BNSettingsGetJson
_BNSettingsGetJson.restype = ctypes.POINTER(ctypes.c_byte)
_BNSettingsGetJson.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(SettingsScopeEnum),
]
# noinspection PyPep8Naming
def BNSettingsGetJson(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
view: ctypes.POINTER(BNBinaryView),
scope: ctypes.POINTER(SettingsScopeEnum)
) -> Optional[Optional[str]]:
result = _BNSettingsGetJson(settings, cstr(key), view, scope)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNSettingsGetString
_BNSettingsGetString = core.BNSettingsGetString
_BNSettingsGetString.restype = ctypes.POINTER(ctypes.c_byte)
_BNSettingsGetString.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(SettingsScopeEnum),
]
# noinspection PyPep8Naming
def BNSettingsGetString(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
view: ctypes.POINTER(BNBinaryView),
scope: ctypes.POINTER(SettingsScopeEnum)
) -> Optional[Optional[str]]:
result = _BNSettingsGetString(settings, cstr(key), view, scope)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNSettingsGetStringList
_BNSettingsGetStringList = core.BNSettingsGetStringList
_BNSettingsGetStringList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNSettingsGetStringList.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(SettingsScopeEnum),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNSettingsGetStringList(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
view: ctypes.POINTER(BNBinaryView),
scope: ctypes.POINTER(SettingsScopeEnum),
inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNSettingsGetStringList(settings, cstr(key), view, scope, inoutSize)
if not result:
return None
return result
# -------------------------------------------------------
# _BNSettingsGetUInt64
_BNSettingsGetUInt64 = core.BNSettingsGetUInt64
_BNSettingsGetUInt64.restype = ctypes.c_ulonglong
_BNSettingsGetUInt64.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(SettingsScopeEnum),
]
# noinspection PyPep8Naming
def BNSettingsGetUInt64(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
view: ctypes.POINTER(BNBinaryView),
scope: ctypes.POINTER(SettingsScopeEnum)
) -> int:
return _BNSettingsGetUInt64(settings, cstr(key), view, scope)
# -------------------------------------------------------
# _BNSettingsIsEmpty
_BNSettingsIsEmpty = core.BNSettingsIsEmpty
_BNSettingsIsEmpty.restype = ctypes.c_bool
_BNSettingsIsEmpty.argtypes = [
ctypes.POINTER(BNSettings),
]
# noinspection PyPep8Naming
def BNSettingsIsEmpty(
settings: ctypes.POINTER(BNSettings)
) -> bool:
return _BNSettingsIsEmpty(settings)
# -------------------------------------------------------
# _BNSettingsKeysList
_BNSettingsKeysList = core.BNSettingsKeysList
_BNSettingsKeysList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNSettingsKeysList.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNSettingsKeysList(
settings: ctypes.POINTER(BNSettings),
inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNSettingsKeysList(settings, inoutSize)
if not result:
return None
return result
# -------------------------------------------------------
# _BNSettingsQueryPropertyStringList
_BNSettingsQueryPropertyStringList = core.BNSettingsQueryPropertyStringList
_BNSettingsQueryPropertyStringList.restype = ctypes.POINTER(ctypes.c_char_p)
_BNSettingsQueryPropertyStringList.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNSettingsQueryPropertyStringList(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
property: Optional[str],
inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNSettingsQueryPropertyStringList(settings, cstr(key), cstr(property), inoutSize)
if not result:
return None
return result
# -------------------------------------------------------
# _BNSettingsRegisterGroup
_BNSettingsRegisterGroup = core.BNSettingsRegisterGroup
_BNSettingsRegisterGroup.restype = ctypes.c_bool
_BNSettingsRegisterGroup.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSettingsRegisterGroup(
settings: ctypes.POINTER(BNSettings),
group: Optional[str],
title: Optional[str]
) -> bool:
return _BNSettingsRegisterGroup(settings, cstr(group), cstr(title))
# -------------------------------------------------------
# _BNSettingsRegisterSetting
_BNSettingsRegisterSetting = core.BNSettingsRegisterSetting
_BNSettingsRegisterSetting.restype = ctypes.c_bool
_BNSettingsRegisterSetting.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSettingsRegisterSetting(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
properties: Optional[str]
) -> bool:
return _BNSettingsRegisterSetting(settings, cstr(key), cstr(properties))
# -------------------------------------------------------
# _BNSettingsReset
_BNSettingsReset = core.BNSettingsReset
_BNSettingsReset.restype = ctypes.c_bool
_BNSettingsReset.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
]
# noinspection PyPep8Naming
def BNSettingsReset(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope
) -> bool:
return _BNSettingsReset(settings, cstr(key), view, scope)
# -------------------------------------------------------
# _BNSettingsResetAll
_BNSettingsResetAll = core.BNSettingsResetAll
_BNSettingsResetAll.restype = ctypes.c_bool
_BNSettingsResetAll.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSettingsResetAll(
settings: ctypes.POINTER(BNSettings),
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope,
schemaOnly: bool
) -> bool:
return _BNSettingsResetAll(settings, view, scope, schemaOnly)
# -------------------------------------------------------
# _BNSettingsSerializeSchema
_BNSettingsSerializeSchema = core.BNSettingsSerializeSchema
_BNSettingsSerializeSchema.restype = ctypes.POINTER(ctypes.c_byte)
_BNSettingsSerializeSchema.argtypes = [
ctypes.POINTER(BNSettings),
]
# noinspection PyPep8Naming
def BNSettingsSerializeSchema(
settings: ctypes.POINTER(BNSettings)
) -> Optional[Optional[str]]:
result = _BNSettingsSerializeSchema(settings)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNSettingsSetBool
_BNSettingsSetBool = core.BNSettingsSetBool
_BNSettingsSetBool.restype = ctypes.c_bool
_BNSettingsSetBool.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSettingsSetBool(
settings: ctypes.POINTER(BNSettings),
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope,
key: Optional[str],
value: bool
) -> bool:
return _BNSettingsSetBool(settings, view, scope, cstr(key), value)
# -------------------------------------------------------
# _BNSettingsSetDouble
_BNSettingsSetDouble = core.BNSettingsSetDouble
_BNSettingsSetDouble.restype = ctypes.c_bool
_BNSettingsSetDouble.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
ctypes.c_char_p,
ctypes.c_double,
]
# noinspection PyPep8Naming
def BNSettingsSetDouble(
settings: ctypes.POINTER(BNSettings),
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope,
key: Optional[str],
value: float
) -> bool:
return _BNSettingsSetDouble(settings, view, scope, cstr(key), value)
# -------------------------------------------------------
# _BNSettingsSetInt64
_BNSettingsSetInt64 = core.BNSettingsSetInt64
_BNSettingsSetInt64.restype = ctypes.c_bool
_BNSettingsSetInt64.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
ctypes.c_char_p,
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNSettingsSetInt64(
settings: ctypes.POINTER(BNSettings),
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope,
key: Optional[str],
value: int
) -> bool:
return _BNSettingsSetInt64(settings, view, scope, cstr(key), value)
# -------------------------------------------------------
# _BNSettingsSetJson
_BNSettingsSetJson = core.BNSettingsSetJson
_BNSettingsSetJson.restype = ctypes.c_bool
_BNSettingsSetJson.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSettingsSetJson(
settings: ctypes.POINTER(BNSettings),
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope,
key: Optional[str],
value: Optional[str]
) -> bool:
return _BNSettingsSetJson(settings, view, scope, cstr(key), cstr(value))
# -------------------------------------------------------
# _BNSettingsSetResourceId
_BNSettingsSetResourceId = core.BNSettingsSetResourceId
_BNSettingsSetResourceId.restype = None
_BNSettingsSetResourceId.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSettingsSetResourceId(
settings: ctypes.POINTER(BNSettings),
resourceId: Optional[str]
) -> None:
return _BNSettingsSetResourceId(settings, cstr(resourceId))
# -------------------------------------------------------
# _BNSettingsSetString
_BNSettingsSetString = core.BNSettingsSetString
_BNSettingsSetString.restype = ctypes.c_bool
_BNSettingsSetString.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSettingsSetString(
settings: ctypes.POINTER(BNSettings),
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope,
key: Optional[str],
value: Optional[str]
) -> bool:
return _BNSettingsSetString(settings, view, scope, cstr(key), cstr(value))
# -------------------------------------------------------
# _BNSettingsSetStringList
_BNSettingsSetStringList = core.BNSettingsSetStringList
_BNSettingsSetStringList.restype = ctypes.c_bool
_BNSettingsSetStringList.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSettingsSetStringList(
settings: ctypes.POINTER(BNSettings),
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope,
key: Optional[str],
value: ctypes.POINTER(ctypes.c_char_p),
size: int
) -> bool:
return _BNSettingsSetStringList(settings, view, scope, cstr(key), value, size)
# -------------------------------------------------------
# _BNSettingsSetUInt64
_BNSettingsSetUInt64 = core.BNSettingsSetUInt64
_BNSettingsSetUInt64.restype = ctypes.c_bool
_BNSettingsSetUInt64.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.POINTER(BNBinaryView),
SettingsScopeEnum,
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSettingsSetUInt64(
settings: ctypes.POINTER(BNSettings),
view: ctypes.POINTER(BNBinaryView),
scope: SettingsScope,
key: Optional[str],
value: int
) -> bool:
return _BNSettingsSetUInt64(settings, view, scope, cstr(key), value)
# -------------------------------------------------------
# _BNSettingsUpdateBoolProperty
_BNSettingsUpdateBoolProperty = core.BNSettingsUpdateBoolProperty
_BNSettingsUpdateBoolProperty.restype = ctypes.c_bool
_BNSettingsUpdateBoolProperty.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNSettingsUpdateBoolProperty(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
property: Optional[str],
value: bool
) -> bool:
return _BNSettingsUpdateBoolProperty(settings, cstr(key), cstr(property), value)
# -------------------------------------------------------
# _BNSettingsUpdateDoubleProperty
_BNSettingsUpdateDoubleProperty = core.BNSettingsUpdateDoubleProperty
_BNSettingsUpdateDoubleProperty.restype = ctypes.c_bool
_BNSettingsUpdateDoubleProperty.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_double,
]
# noinspection PyPep8Naming
def BNSettingsUpdateDoubleProperty(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
property: Optional[str],
value: float
) -> bool:
return _BNSettingsUpdateDoubleProperty(settings, cstr(key), cstr(property), value)
# -------------------------------------------------------
# _BNSettingsUpdateInt64Property
_BNSettingsUpdateInt64Property = core.BNSettingsUpdateInt64Property
_BNSettingsUpdateInt64Property.restype = ctypes.c_bool
_BNSettingsUpdateInt64Property.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNSettingsUpdateInt64Property(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
property: Optional[str],
value: int
) -> bool:
return _BNSettingsUpdateInt64Property(settings, cstr(key), cstr(property), value)
# -------------------------------------------------------
# _BNSettingsUpdateProperty
_BNSettingsUpdateProperty = core.BNSettingsUpdateProperty
_BNSettingsUpdateProperty.restype = ctypes.c_bool
_BNSettingsUpdateProperty.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSettingsUpdateProperty(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
property: Optional[str]
) -> bool:
return _BNSettingsUpdateProperty(settings, cstr(key), cstr(property))
# -------------------------------------------------------
# _BNSettingsUpdateStringListProperty
_BNSettingsUpdateStringListProperty = core.BNSettingsUpdateStringListProperty
_BNSettingsUpdateStringListProperty.restype = ctypes.c_bool
_BNSettingsUpdateStringListProperty.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSettingsUpdateStringListProperty(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
property: Optional[str],
value: ctypes.POINTER(ctypes.c_char_p),
size: int
) -> bool:
return _BNSettingsUpdateStringListProperty(settings, cstr(key), cstr(property), value, size)
# -------------------------------------------------------
# _BNSettingsUpdateStringProperty
_BNSettingsUpdateStringProperty = core.BNSettingsUpdateStringProperty
_BNSettingsUpdateStringProperty.restype = ctypes.c_bool
_BNSettingsUpdateStringProperty.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNSettingsUpdateStringProperty(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
property: Optional[str],
value: Optional[str]
) -> bool:
return _BNSettingsUpdateStringProperty(settings, cstr(key), cstr(property), cstr(value))
# -------------------------------------------------------
# _BNSettingsUpdateUInt64Property
_BNSettingsUpdateUInt64Property = core.BNSettingsUpdateUInt64Property
_BNSettingsUpdateUInt64Property.restype = ctypes.c_bool
_BNSettingsUpdateUInt64Property.argtypes = [
ctypes.POINTER(BNSettings),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSettingsUpdateUInt64Property(
settings: ctypes.POINTER(BNSettings),
key: Optional[str],
property: Optional[str],
value: int
) -> bool:
return _BNSettingsUpdateUInt64Property(settings, cstr(key), cstr(property), value)
# -------------------------------------------------------
# _BNShowGraphReport
_BNShowGraphReport = core.BNShowGraphReport
_BNShowGraphReport.restype = None
_BNShowGraphReport.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNShowGraphReport(
view: ctypes.POINTER(BNBinaryView),
title: Optional[str],
graph: ctypes.POINTER(BNFlowGraph)
) -> None:
return _BNShowGraphReport(view, cstr(title), graph)
# -------------------------------------------------------
# _BNShowHTMLReport
_BNShowHTMLReport = core.BNShowHTMLReport
_BNShowHTMLReport.restype = None
_BNShowHTMLReport.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNShowHTMLReport(
view: ctypes.POINTER(BNBinaryView),
title: Optional[str],
contents: Optional[str],
plaintext: Optional[str]
) -> None:
return _BNShowHTMLReport(view, cstr(title), cstr(contents), cstr(plaintext))
# -------------------------------------------------------
# _BNShowMarkdownReport
_BNShowMarkdownReport = core.BNShowMarkdownReport
_BNShowMarkdownReport.restype = None
_BNShowMarkdownReport.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNShowMarkdownReport(
view: ctypes.POINTER(BNBinaryView),
title: Optional[str],
contents: Optional[str],
plaintext: Optional[str]
) -> None:
return _BNShowMarkdownReport(view, cstr(title), cstr(contents), cstr(plaintext))
# -------------------------------------------------------
# _BNShowMessageBox
_BNShowMessageBox = core.BNShowMessageBox
_BNShowMessageBox.restype = MessageBoxButtonResultEnum
_BNShowMessageBox.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
MessageBoxButtonSetEnum,
MessageBoxIconEnum,
]
# noinspection PyPep8Naming
def BNShowMessageBox(
title: Optional[str],
text: Optional[str],
buttons: MessageBoxButtonSet,
icon: MessageBoxIcon
) -> MessageBoxButtonResult:
return _BNShowMessageBox(cstr(title), cstr(text), buttons, icon)
# -------------------------------------------------------
# _BNShowPlainTextReport
_BNShowPlainTextReport = core.BNShowPlainTextReport
_BNShowPlainTextReport.restype = None
_BNShowPlainTextReport.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNShowPlainTextReport(
view: ctypes.POINTER(BNBinaryView),
title: Optional[str],
contents: Optional[str]
) -> None:
return _BNShowPlainTextReport(view, cstr(title), cstr(contents))
# -------------------------------------------------------
# _BNShowReportCollection
_BNShowReportCollection = core.BNShowReportCollection
_BNShowReportCollection.restype = None
_BNShowReportCollection.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(BNReportCollection),
]
# noinspection PyPep8Naming
def BNShowReportCollection(
title: Optional[str],
reports: ctypes.POINTER(BNReportCollection)
) -> None:
return _BNShowReportCollection(cstr(title), reports)
# -------------------------------------------------------
# _BNShutdown
_BNShutdown = core.BNShutdown
_BNShutdown.restype = None
_BNShutdown.argtypes = [
]
# noinspection PyPep8Naming
def BNShutdown(
) -> None:
return _BNShutdown()
# -------------------------------------------------------
# _BNSkipAndReturnValue
_BNSkipAndReturnValue = core.BNSkipAndReturnValue
_BNSkipAndReturnValue.restype = ctypes.c_bool
_BNSkipAndReturnValue.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNArchitecture),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNSkipAndReturnValue(
view: ctypes.POINTER(BNBinaryView),
arch: ctypes.POINTER(BNArchitecture),
addr: int,
value: int
) -> bool:
return _BNSkipAndReturnValue(view, arch, addr, value)
# -------------------------------------------------------
# _BNSnapshotHasAncestor
_BNSnapshotHasAncestor = core.BNSnapshotHasAncestor
_BNSnapshotHasAncestor.restype = ctypes.c_bool
_BNSnapshotHasAncestor.argtypes = [
ctypes.POINTER(BNSnapshot),
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNSnapshotHasAncestor(
snapshot: ctypes.POINTER(BNSnapshot),
other: ctypes.POINTER(BNSnapshot)
) -> bool:
return _BNSnapshotHasAncestor(snapshot, other)
# -------------------------------------------------------
# _BNSnapshotHasContents
_BNSnapshotHasContents = core.BNSnapshotHasContents
_BNSnapshotHasContents.restype = ctypes.c_bool
_BNSnapshotHasContents.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNSnapshotHasContents(
snapshot: ctypes.POINTER(BNSnapshot)
) -> bool:
return _BNSnapshotHasContents(snapshot)
# -------------------------------------------------------
# _BNSnapshotHasData
_BNSnapshotHasData = core.BNSnapshotHasData
_BNSnapshotHasData.restype = ctypes.c_bool
_BNSnapshotHasData.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNSnapshotHasData(
db: ctypes.POINTER(BNDatabase),
id: int
) -> bool:
return _BNSnapshotHasData(db, id)
# -------------------------------------------------------
# _BNSnapshotHasUndo
_BNSnapshotHasUndo = core.BNSnapshotHasUndo
_BNSnapshotHasUndo.restype = ctypes.c_bool
_BNSnapshotHasUndo.argtypes = [
ctypes.POINTER(BNSnapshot),
]
# noinspection PyPep8Naming
def BNSnapshotHasUndo(
snapshot: ctypes.POINTER(BNSnapshot)
) -> bool:
return _BNSnapshotHasUndo(snapshot)
# -------------------------------------------------------
# _BNSnapshotStoreData
_BNSnapshotStoreData = core.BNSnapshotStoreData
_BNSnapshotStoreData.restype = ctypes.c_bool
_BNSnapshotStoreData.argtypes = [
ctypes.POINTER(BNSnapshot),
ctypes.POINTER(BNKeyValueStore),
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNSnapshotStoreData(
snapshot: ctypes.POINTER(BNSnapshot),
data: ctypes.POINTER(BNKeyValueStore),
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> bool:
return _BNSnapshotStoreData(snapshot, data, ctxt, progress)
# -------------------------------------------------------
# _BNSplitVariable
_BNSplitVariable = core.BNSplitVariable
_BNSplitVariable.restype = None
_BNSplitVariable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNSplitVariable(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable)
) -> None:
return _BNSplitVariable(func, var)
# -------------------------------------------------------
# _BNStartFlowGraphLayout
_BNStartFlowGraphLayout = core.BNStartFlowGraphLayout
_BNStartFlowGraphLayout.restype = ctypes.POINTER(BNFlowGraphLayoutRequest)
_BNStartFlowGraphLayout.argtypes = [
ctypes.POINTER(BNFlowGraph),
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
]
# noinspection PyPep8Naming
def BNStartFlowGraphLayout(
graph: ctypes.POINTER(BNFlowGraph),
ctxt: Optional[ctypes.c_void_p],
func: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
) -> Optional[ctypes.POINTER(BNFlowGraphLayoutRequest)]:
result = _BNStartFlowGraphLayout(graph, ctxt, func)
if not result:
return None
return result
# -------------------------------------------------------
# _BNStopScriptingInstance
_BNStopScriptingInstance = core.BNStopScriptingInstance
_BNStopScriptingInstance.restype = None
_BNStopScriptingInstance.argtypes = [
ctypes.POINTER(BNScriptingInstance),
]
# noinspection PyPep8Naming
def BNStopScriptingInstance(
instance: ctypes.POINTER(BNScriptingInstance)
) -> None:
return _BNStopScriptingInstance(instance)
# -------------------------------------------------------
# _BNStoreSecretsProviderData
_BNStoreSecretsProviderData = core.BNStoreSecretsProviderData
_BNStoreSecretsProviderData.restype = ctypes.c_bool
_BNStoreSecretsProviderData.argtypes = [
ctypes.POINTER(BNSecretsProvider),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNStoreSecretsProviderData(
provider: ctypes.POINTER(BNSecretsProvider),
key: Optional[str],
data: Optional[str]
) -> bool:
return _BNStoreSecretsProviderData(provider, cstr(key), cstr(data))
# -------------------------------------------------------
# _BNStructureBuilderPropagatesDataVariableReferences
_BNStructureBuilderPropagatesDataVariableReferences = core.BNStructureBuilderPropagatesDataVariableReferences
_BNStructureBuilderPropagatesDataVariableReferences.restype = ctypes.c_bool
_BNStructureBuilderPropagatesDataVariableReferences.argtypes = [
ctypes.POINTER(BNStructureBuilder),
]
# noinspection PyPep8Naming
def BNStructureBuilderPropagatesDataVariableReferences(
s: ctypes.POINTER(BNStructureBuilder)
) -> bool:
return _BNStructureBuilderPropagatesDataVariableReferences(s)
# -------------------------------------------------------
# _BNStructurePropagatesDataVariableReferences
_BNStructurePropagatesDataVariableReferences = core.BNStructurePropagatesDataVariableReferences
_BNStructurePropagatesDataVariableReferences.restype = ctypes.c_bool
_BNStructurePropagatesDataVariableReferences.argtypes = [
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNStructurePropagatesDataVariableReferences(
s: ctypes.POINTER(BNStructure)
) -> bool:
return _BNStructurePropagatesDataVariableReferences(s)
# -------------------------------------------------------
# _BNStructureWithReplacedEnumeration
_BNStructureWithReplacedEnumeration = core.BNStructureWithReplacedEnumeration
_BNStructureWithReplacedEnumeration.restype = ctypes.POINTER(BNStructure)
_BNStructureWithReplacedEnumeration.argtypes = [
ctypes.POINTER(BNStructure),
ctypes.POINTER(BNEnumeration),
ctypes.POINTER(BNEnumeration),
]
# noinspection PyPep8Naming
def BNStructureWithReplacedEnumeration(
s: ctypes.POINTER(BNStructure),
from_: ctypes.POINTER(BNEnumeration),
to: ctypes.POINTER(BNEnumeration)
) -> Optional[ctypes.POINTER(BNStructure)]:
result = _BNStructureWithReplacedEnumeration(s, from_, to)
if not result:
return None
return result
# -------------------------------------------------------
# _BNStructureWithReplacedNamedTypeReference
_BNStructureWithReplacedNamedTypeReference = core.BNStructureWithReplacedNamedTypeReference
_BNStructureWithReplacedNamedTypeReference.restype = ctypes.POINTER(BNStructure)
_BNStructureWithReplacedNamedTypeReference.argtypes = [
ctypes.POINTER(BNStructure),
ctypes.POINTER(BNNamedTypeReference),
ctypes.POINTER(BNNamedTypeReference),
]
# noinspection PyPep8Naming
def BNStructureWithReplacedNamedTypeReference(
s: ctypes.POINTER(BNStructure),
from_: ctypes.POINTER(BNNamedTypeReference),
to: ctypes.POINTER(BNNamedTypeReference)
) -> Optional[ctypes.POINTER(BNStructure)]:
result = _BNStructureWithReplacedNamedTypeReference(s, from_, to)
if not result:
return None
return result
# -------------------------------------------------------
# _BNStructureWithReplacedStructure
_BNStructureWithReplacedStructure = core.BNStructureWithReplacedStructure
_BNStructureWithReplacedStructure.restype = ctypes.POINTER(BNStructure)
_BNStructureWithReplacedStructure.argtypes = [
ctypes.POINTER(BNStructure),
ctypes.POINTER(BNStructure),
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNStructureWithReplacedStructure(
s: ctypes.POINTER(BNStructure),
from_: ctypes.POINTER(BNStructure),
to: ctypes.POINTER(BNStructure)
) -> Optional[ctypes.POINTER(BNStructure)]:
result = _BNStructureWithReplacedStructure(s, from_, to)
if not result:
return None
return result
# -------------------------------------------------------
# _BNTagGetData
_BNTagGetData = core.BNTagGetData
_BNTagGetData.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagGetData.argtypes = [
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNTagGetData(
tag: ctypes.POINTER(BNTag)
) -> Optional[Optional[str]]:
result = _BNTagGetData(tag)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNTagGetId
_BNTagGetId = core.BNTagGetId
_BNTagGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagGetId.argtypes = [
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNTagGetId(
tag: ctypes.POINTER(BNTag)
) -> Optional[Optional[str]]:
result = _BNTagGetId(tag)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNTagGetType
_BNTagGetType = core.BNTagGetType
_BNTagGetType.restype = ctypes.POINTER(BNTagType)
_BNTagGetType.argtypes = [
ctypes.POINTER(BNTag),
]
# noinspection PyPep8Naming
def BNTagGetType(
tag: ctypes.POINTER(BNTag)
) -> Optional[ctypes.POINTER(BNTagType)]:
result = _BNTagGetType(tag)
if not result:
return None
return result
# -------------------------------------------------------
# _BNTagSetData
_BNTagSetData = core.BNTagSetData
_BNTagSetData.restype = None
_BNTagSetData.argtypes = [
ctypes.POINTER(BNTag),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTagSetData(
tag: ctypes.POINTER(BNTag),
data: Optional[str]
) -> None:
return _BNTagSetData(tag, cstr(data))
# -------------------------------------------------------
# _BNTagTypeGetIcon
_BNTagTypeGetIcon = core.BNTagTypeGetIcon
_BNTagTypeGetIcon.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagTypeGetIcon.argtypes = [
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNTagTypeGetIcon(
tagType: ctypes.POINTER(BNTagType)
) -> Optional[Optional[str]]:
result = _BNTagTypeGetIcon(tagType)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNTagTypeGetId
_BNTagTypeGetId = core.BNTagTypeGetId
_BNTagTypeGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagTypeGetId.argtypes = [
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNTagTypeGetId(
tagType: ctypes.POINTER(BNTagType)
) -> Optional[Optional[str]]:
result = _BNTagTypeGetId(tagType)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNTagTypeGetName
_BNTagTypeGetName = core.BNTagTypeGetName
_BNTagTypeGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNTagTypeGetName.argtypes = [
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNTagTypeGetName(
tagType: ctypes.POINTER(BNTagType)
) -> Optional[Optional[str]]:
result = _BNTagTypeGetName(tagType)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNTagTypeGetType
_BNTagTypeGetType = core.BNTagTypeGetType
_BNTagTypeGetType.restype = TagTypeTypeEnum
_BNTagTypeGetType.argtypes = [
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNTagTypeGetType(
tagType: ctypes.POINTER(BNTagType)
) -> TagTypeType:
return _BNTagTypeGetType(tagType)
# -------------------------------------------------------
# _BNTagTypeGetView
_BNTagTypeGetView = core.BNTagTypeGetView
_BNTagTypeGetView.restype = ctypes.POINTER(BNBinaryView)
_BNTagTypeGetView.argtypes = [
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNTagTypeGetView(
tagType: ctypes.POINTER(BNTagType)
) -> Optional[ctypes.POINTER(BNBinaryView)]:
result = _BNTagTypeGetView(tagType)
if not result:
return None
return result
# -------------------------------------------------------
# _BNTagTypeGetVisible
_BNTagTypeGetVisible = core.BNTagTypeGetVisible
_BNTagTypeGetVisible.restype = ctypes.c_bool
_BNTagTypeGetVisible.argtypes = [
ctypes.POINTER(BNTagType),
]
# noinspection PyPep8Naming
def BNTagTypeGetVisible(
tagType: ctypes.POINTER(BNTagType)
) -> bool:
return _BNTagTypeGetVisible(tagType)
# -------------------------------------------------------
# _BNTagTypeSetIcon
_BNTagTypeSetIcon = core.BNTagTypeSetIcon
_BNTagTypeSetIcon.restype = None
_BNTagTypeSetIcon.argtypes = [
ctypes.POINTER(BNTagType),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTagTypeSetIcon(
tagType: ctypes.POINTER(BNTagType),
icon: Optional[str]
) -> None:
return _BNTagTypeSetIcon(tagType, cstr(icon))
# -------------------------------------------------------
# _BNTagTypeSetName
_BNTagTypeSetName = core.BNTagTypeSetName
_BNTagTypeSetName.restype = None
_BNTagTypeSetName.argtypes = [
ctypes.POINTER(BNTagType),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTagTypeSetName(
tagType: ctypes.POINTER(BNTagType),
name: Optional[str]
) -> None:
return _BNTagTypeSetName(tagType, cstr(name))
# -------------------------------------------------------
# _BNTagTypeSetType
_BNTagTypeSetType = core.BNTagTypeSetType
_BNTagTypeSetType.restype = None
_BNTagTypeSetType.argtypes = [
ctypes.POINTER(BNTagType),
TagTypeTypeEnum,
]
# noinspection PyPep8Naming
def BNTagTypeSetType(
tagType: ctypes.POINTER(BNTagType),
type: TagTypeType
) -> None:
return _BNTagTypeSetType(tagType, type)
# -------------------------------------------------------
# _BNTagTypeSetVisible
_BNTagTypeSetVisible = core.BNTagTypeSetVisible
_BNTagTypeSetVisible.restype = None
_BNTagTypeSetVisible.argtypes = [
ctypes.POINTER(BNTagType),
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNTagTypeSetVisible(
tagType: ctypes.POINTER(BNTagType),
visible: bool
) -> None:
return _BNTagTypeSetVisible(tagType, visible)
# -------------------------------------------------------
# _BNToVariableIdentifier
_BNToVariableIdentifier = core.BNToVariableIdentifier
_BNToVariableIdentifier.restype = ctypes.c_ulonglong
_BNToVariableIdentifier.argtypes = [
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNToVariableIdentifier(
var: ctypes.POINTER(BNVariable)
) -> int:
return _BNToVariableIdentifier(var)
# -------------------------------------------------------
# _BNTrimDatabaseSnapshot
_BNTrimDatabaseSnapshot = core.BNTrimDatabaseSnapshot
_BNTrimDatabaseSnapshot.restype = ctypes.c_bool
_BNTrimDatabaseSnapshot.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_longlong,
]
# noinspection PyPep8Naming
def BNTrimDatabaseSnapshot(
database: ctypes.POINTER(BNDatabase),
id: int
) -> bool:
return _BNTrimDatabaseSnapshot(database, id)
# -------------------------------------------------------
# _BNTypeArchiveDeserializeSnapshot
_BNTypeArchiveDeserializeSnapshot = core.BNTypeArchiveDeserializeSnapshot
_BNTypeArchiveDeserializeSnapshot.restype = ctypes.POINTER(ctypes.c_byte)
_BNTypeArchiveDeserializeSnapshot.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNTypeArchiveDeserializeSnapshot(
archive: ctypes.POINTER(BNTypeArchive),
buffer: ctypes.POINTER(BNDataBuffer)
) -> Optional[Optional[str]]:
result = _BNTypeArchiveDeserializeSnapshot(archive, buffer)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNTypeArchiveMergeSnapshots
_BNTypeArchiveMergeSnapshots = core.BNTypeArchiveMergeSnapshots
_BNTypeArchiveMergeSnapshots.restype = ctypes.c_bool
_BNTypeArchiveMergeSnapshots.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
ctypes.POINTER(ctypes.c_char_p),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNTypeArchiveMergeSnapshots(
archive: ctypes.POINTER(BNTypeArchive),
baseSnapshot: Optional[str],
firstSnapshot: Optional[str],
secondSnapshot: Optional[str],
mergeConflictKeysIn: ctypes.POINTER(ctypes.c_char_p),
mergeConflictValuesIn: ctypes.POINTER(ctypes.c_char_p),
mergeConflictCountIn: int,
mergeConflictsOut: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
mergeConflictCountOut: ctypes.POINTER(ctypes.c_ulonglong),
result: ctypes.POINTER(ctypes.c_char_p),
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
context: Optional[ctypes.c_void_p]
) -> bool:
return _BNTypeArchiveMergeSnapshots(archive, cstr(baseSnapshot), cstr(firstSnapshot), cstr(secondSnapshot), mergeConflictKeysIn, mergeConflictValuesIn, mergeConflictCountIn, mergeConflictsOut, mergeConflictCountOut, result, progress, context)
# -------------------------------------------------------
# _BNTypeArchiveNewSnapshotTransaction
_BNTypeArchiveNewSnapshotTransaction = core.BNTypeArchiveNewSnapshotTransaction
_BNTypeArchiveNewSnapshotTransaction.restype = ctypes.POINTER(ctypes.c_byte)
_BNTypeArchiveNewSnapshotTransaction.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p),
ctypes.c_void_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNTypeArchiveNewSnapshotTransaction(
archive: ctypes.POINTER(BNTypeArchive),
func: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_char_p),
context: Optional[ctypes.c_void_p],
parents: ctypes.POINTER(ctypes.c_char_p),
parentCount: int
) -> Optional[Optional[str]]:
result = _BNTypeArchiveNewSnapshotTransaction(archive, func, context, parents, parentCount)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNTypeArchiveQueryMetadata
_BNTypeArchiveQueryMetadata = core.BNTypeArchiveQueryMetadata
_BNTypeArchiveQueryMetadata.restype = ctypes.POINTER(BNMetadata)
_BNTypeArchiveQueryMetadata.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTypeArchiveQueryMetadata(
archive: ctypes.POINTER(BNTypeArchive),
key: Optional[str]
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNTypeArchiveQueryMetadata(archive, cstr(key))
if not result:
return None
return result
# -------------------------------------------------------
# _BNTypeArchiveRemoveMetadata
_BNTypeArchiveRemoveMetadata = core.BNTypeArchiveRemoveMetadata
_BNTypeArchiveRemoveMetadata.restype = ctypes.c_bool
_BNTypeArchiveRemoveMetadata.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTypeArchiveRemoveMetadata(
archive: ctypes.POINTER(BNTypeArchive),
key: Optional[str]
) -> bool:
return _BNTypeArchiveRemoveMetadata(archive, cstr(key))
# -------------------------------------------------------
# _BNTypeArchiveSerializeSnapshot
_BNTypeArchiveSerializeSnapshot = core.BNTypeArchiveSerializeSnapshot
_BNTypeArchiveSerializeSnapshot.restype = ctypes.POINTER(BNDataBuffer)
_BNTypeArchiveSerializeSnapshot.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTypeArchiveSerializeSnapshot(
archive: ctypes.POINTER(BNTypeArchive),
snapshot: Optional[str]
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNTypeArchiveSerializeSnapshot(archive, cstr(snapshot))
if not result:
return None
return result
# -------------------------------------------------------
# _BNTypeArchiveStoreMetadata
_BNTypeArchiveStoreMetadata = core.BNTypeArchiveStoreMetadata
_BNTypeArchiveStoreMetadata.restype = ctypes.c_bool
_BNTypeArchiveStoreMetadata.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.c_char_p,
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNTypeArchiveStoreMetadata(
archive: ctypes.POINTER(BNTypeArchive),
key: Optional[str],
value: ctypes.POINTER(BNMetadata)
) -> bool:
return _BNTypeArchiveStoreMetadata(archive, cstr(key), value)
# -------------------------------------------------------
# _BNTypeBuilderGetReferenceType
_BNTypeBuilderGetReferenceType = core.BNTypeBuilderGetReferenceType
_BNTypeBuilderGetReferenceType.restype = ReferenceTypeEnum
_BNTypeBuilderGetReferenceType.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNTypeBuilderGetReferenceType(
type: ctypes.POINTER(BNTypeBuilder)
) -> ReferenceType:
return _BNTypeBuilderGetReferenceType(type)
# -------------------------------------------------------
# _BNTypeBuilderGetStructureName
_BNTypeBuilderGetStructureName = core.BNTypeBuilderGetStructureName
_BNTypeBuilderGetStructureName.restype = BNQualifiedName
_BNTypeBuilderGetStructureName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNTypeBuilderGetStructureName(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNQualifiedName:
return _BNTypeBuilderGetStructureName(type)
# -------------------------------------------------------
# _BNTypeBuilderGetSystemCallNumber
_BNTypeBuilderGetSystemCallNumber = core.BNTypeBuilderGetSystemCallNumber
_BNTypeBuilderGetSystemCallNumber.restype = ctypes.c_uint
_BNTypeBuilderGetSystemCallNumber.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNTypeBuilderGetSystemCallNumber(
type: ctypes.POINTER(BNTypeBuilder)
) -> int:
return _BNTypeBuilderGetSystemCallNumber(type)
# -------------------------------------------------------
# _BNTypeBuilderGetTypeName
_BNTypeBuilderGetTypeName = core.BNTypeBuilderGetTypeName
_BNTypeBuilderGetTypeName.restype = BNQualifiedName
_BNTypeBuilderGetTypeName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNTypeBuilderGetTypeName(
nt: ctypes.POINTER(BNTypeBuilder)
) -> BNQualifiedName:
return _BNTypeBuilderGetTypeName(nt)
# -------------------------------------------------------
# _BNTypeBuilderHasVariableArguments
_BNTypeBuilderHasVariableArguments = core.BNTypeBuilderHasVariableArguments
_BNTypeBuilderHasVariableArguments.restype = BNBoolWithConfidence
_BNTypeBuilderHasVariableArguments.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNTypeBuilderHasVariableArguments(
type: ctypes.POINTER(BNTypeBuilder)
) -> BNBoolWithConfidence:
return _BNTypeBuilderHasVariableArguments(type)
# -------------------------------------------------------
# _BNTypeBuilderIsSystemCall
_BNTypeBuilderIsSystemCall = core.BNTypeBuilderIsSystemCall
_BNTypeBuilderIsSystemCall.restype = ctypes.c_bool
_BNTypeBuilderIsSystemCall.argtypes = [
ctypes.POINTER(BNTypeBuilder),
]
# noinspection PyPep8Naming
def BNTypeBuilderIsSystemCall(
type: ctypes.POINTER(BNTypeBuilder)
) -> bool:
return _BNTypeBuilderIsSystemCall(type)
# -------------------------------------------------------
# _BNTypeBuilderSetAlternateName
_BNTypeBuilderSetAlternateName = core.BNTypeBuilderSetAlternateName
_BNTypeBuilderSetAlternateName.restype = None
_BNTypeBuilderSetAlternateName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTypeBuilderSetAlternateName(
type: ctypes.POINTER(BNTypeBuilder),
name: Optional[str]
) -> None:
return _BNTypeBuilderSetAlternateName(type, cstr(name))
# -------------------------------------------------------
# _BNTypeBuilderSetChildType
_BNTypeBuilderSetChildType = core.BNTypeBuilderSetChildType
_BNTypeBuilderSetChildType.restype = None
_BNTypeBuilderSetChildType.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNTypeWithConfidence),
]
# noinspection PyPep8Naming
def BNTypeBuilderSetChildType(
type: ctypes.POINTER(BNTypeBuilder),
child: ctypes.POINTER(BNTypeWithConfidence)
) -> None:
return _BNTypeBuilderSetChildType(type, child)
# -------------------------------------------------------
# _BNTypeBuilderSetConst
_BNTypeBuilderSetConst = core.BNTypeBuilderSetConst
_BNTypeBuilderSetConst.restype = None
_BNTypeBuilderSetConst.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNTypeBuilderSetConst(
type: ctypes.POINTER(BNTypeBuilder),
cnst: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNTypeBuilderSetConst(type, cnst)
# -------------------------------------------------------
# _BNTypeBuilderSetSigned
_BNTypeBuilderSetSigned = core.BNTypeBuilderSetSigned
_BNTypeBuilderSetSigned.restype = None
_BNTypeBuilderSetSigned.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNTypeBuilderSetSigned(
type: ctypes.POINTER(BNTypeBuilder),
sign: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNTypeBuilderSetSigned(type, sign)
# -------------------------------------------------------
# _BNTypeBuilderSetStackAdjustment
_BNTypeBuilderSetStackAdjustment = core.BNTypeBuilderSetStackAdjustment
_BNTypeBuilderSetStackAdjustment.restype = None
_BNTypeBuilderSetStackAdjustment.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNOffsetWithConfidence),
]
# noinspection PyPep8Naming
def BNTypeBuilderSetStackAdjustment(
type: ctypes.POINTER(BNTypeBuilder),
adjust: ctypes.POINTER(BNOffsetWithConfidence)
) -> None:
return _BNTypeBuilderSetStackAdjustment(type, adjust)
# -------------------------------------------------------
# _BNTypeBuilderSetSystemCallNumber
_BNTypeBuilderSetSystemCallNumber = core.BNTypeBuilderSetSystemCallNumber
_BNTypeBuilderSetSystemCallNumber.restype = None
_BNTypeBuilderSetSystemCallNumber.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.c_bool,
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNTypeBuilderSetSystemCallNumber(
type: ctypes.POINTER(BNTypeBuilder),
v: bool,
n: int
) -> None:
return _BNTypeBuilderSetSystemCallNumber(type, v, n)
# -------------------------------------------------------
# _BNTypeBuilderSetTypeName
_BNTypeBuilderSetTypeName = core.BNTypeBuilderSetTypeName
_BNTypeBuilderSetTypeName.restype = None
_BNTypeBuilderSetTypeName.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNTypeBuilderSetTypeName(
type: ctypes.POINTER(BNTypeBuilder),
name: ctypes.POINTER(BNQualifiedName)
) -> None:
return _BNTypeBuilderSetTypeName(type, name)
# -------------------------------------------------------
# _BNTypeBuilderSetVolatile
_BNTypeBuilderSetVolatile = core.BNTypeBuilderSetVolatile
_BNTypeBuilderSetVolatile.restype = None
_BNTypeBuilderSetVolatile.argtypes = [
ctypes.POINTER(BNTypeBuilder),
ctypes.POINTER(BNBoolWithConfidence),
]
# noinspection PyPep8Naming
def BNTypeBuilderSetVolatile(
type: ctypes.POINTER(BNTypeBuilder),
vltl: ctypes.POINTER(BNBoolWithConfidence)
) -> None:
return _BNTypeBuilderSetVolatile(type, vltl)
# -------------------------------------------------------
# _BNTypeContainerAddTypes
_BNTypeContainerAddTypes = core.BNTypeContainerAddTypes
_BNTypeContainerAddTypes.restype = ctypes.c_bool
_BNTypeContainerAddTypes.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.c_ulonglong,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeContainerAddTypes(
container: ctypes.POINTER(BNTypeContainer),
typeNames: ctypes.POINTER(BNQualifiedName),
types: ctypes.POINTER(ctypes.POINTER(BNType)),
typeCount: int,
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
progressContext: Optional[ctypes.c_void_p],
resultNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
resultIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
resultCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeContainerAddTypes(container, typeNames, types, typeCount, progress, progressContext, resultNames, resultIds, resultCount)
# -------------------------------------------------------
# _BNTypeContainerDeleteType
_BNTypeContainerDeleteType = core.BNTypeContainerDeleteType
_BNTypeContainerDeleteType.restype = ctypes.c_bool
_BNTypeContainerDeleteType.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTypeContainerDeleteType(
container: ctypes.POINTER(BNTypeContainer),
typeId: Optional[str]
) -> bool:
return _BNTypeContainerDeleteType(container, cstr(typeId))
# -------------------------------------------------------
# _BNTypeContainerGetId
_BNTypeContainerGetId = core.BNTypeContainerGetId
_BNTypeContainerGetId.restype = ctypes.POINTER(ctypes.c_byte)
_BNTypeContainerGetId.argtypes = [
ctypes.POINTER(BNTypeContainer),
]
# noinspection PyPep8Naming
def BNTypeContainerGetId(
container: ctypes.POINTER(BNTypeContainer)
) -> Optional[Optional[str]]:
result = _BNTypeContainerGetId(container)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNTypeContainerGetName
_BNTypeContainerGetName = core.BNTypeContainerGetName
_BNTypeContainerGetName.restype = ctypes.POINTER(ctypes.c_byte)
_BNTypeContainerGetName.argtypes = [
ctypes.POINTER(BNTypeContainer),
]
# noinspection PyPep8Naming
def BNTypeContainerGetName(
container: ctypes.POINTER(BNTypeContainer)
) -> Optional[Optional[str]]:
result = _BNTypeContainerGetName(container)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNTypeContainerGetPlatform
_BNTypeContainerGetPlatform = core.BNTypeContainerGetPlatform
_BNTypeContainerGetPlatform.restype = ctypes.POINTER(BNPlatform)
_BNTypeContainerGetPlatform.argtypes = [
ctypes.POINTER(BNTypeContainer),
]
# noinspection PyPep8Naming
def BNTypeContainerGetPlatform(
container: ctypes.POINTER(BNTypeContainer)
) -> Optional[ctypes.POINTER(BNPlatform)]:
result = _BNTypeContainerGetPlatform(container)
if not result:
return None
return result
# -------------------------------------------------------
# _BNTypeContainerGetType
_BNTypeContainerGetType = core.BNTypeContainerGetType
_BNTypeContainerGetType.restype = TypeContainerTypeEnum
_BNTypeContainerGetType.argtypes = [
ctypes.POINTER(BNTypeContainer),
]
# noinspection PyPep8Naming
def BNTypeContainerGetType(
container: ctypes.POINTER(BNTypeContainer)
) -> TypeContainerType:
return _BNTypeContainerGetType(container)
# -------------------------------------------------------
# _BNTypeContainerGetTypeById
_BNTypeContainerGetTypeById = core.BNTypeContainerGetTypeById
_BNTypeContainerGetTypeById.restype = ctypes.c_bool
_BNTypeContainerGetTypeById.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.c_char_p,
ctypes.POINTER(ctypes.POINTER(BNType)),
]
# noinspection PyPep8Naming
def BNTypeContainerGetTypeById(
container: ctypes.POINTER(BNTypeContainer),
typeId: Optional[str],
result: ctypes.POINTER(ctypes.POINTER(BNType))
) -> bool:
return _BNTypeContainerGetTypeById(container, cstr(typeId), result)
# -------------------------------------------------------
# _BNTypeContainerGetTypeByName
_BNTypeContainerGetTypeByName = core.BNTypeContainerGetTypeByName
_BNTypeContainerGetTypeByName.restype = ctypes.c_bool
_BNTypeContainerGetTypeByName.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.POINTER(BNType)),
]
# noinspection PyPep8Naming
def BNTypeContainerGetTypeByName(
container: ctypes.POINTER(BNTypeContainer),
typeName: ctypes.POINTER(BNQualifiedName),
result: ctypes.POINTER(ctypes.POINTER(BNType))
) -> bool:
return _BNTypeContainerGetTypeByName(container, typeName, result)
# -------------------------------------------------------
# _BNTypeContainerGetTypeId
_BNTypeContainerGetTypeId = core.BNTypeContainerGetTypeId
_BNTypeContainerGetTypeId.restype = ctypes.c_bool
_BNTypeContainerGetTypeId.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNTypeContainerGetTypeId(
container: ctypes.POINTER(BNTypeContainer),
typeName: ctypes.POINTER(BNQualifiedName),
result: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNTypeContainerGetTypeId(container, typeName, result)
# -------------------------------------------------------
# _BNTypeContainerGetTypeIds
_BNTypeContainerGetTypeIds = core.BNTypeContainerGetTypeIds
_BNTypeContainerGetTypeIds.restype = ctypes.c_bool
_BNTypeContainerGetTypeIds.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeContainerGetTypeIds(
container: ctypes.POINTER(BNTypeContainer),
typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeContainerGetTypeIds(container, typeIds, count)
# -------------------------------------------------------
# _BNTypeContainerGetTypeName
_BNTypeContainerGetTypeName = core.BNTypeContainerGetTypeName
_BNTypeContainerGetTypeName.restype = ctypes.c_bool
_BNTypeContainerGetTypeName.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNTypeContainerGetTypeName(
container: ctypes.POINTER(BNTypeContainer),
typeId: Optional[str],
result: ctypes.POINTER(BNQualifiedName)
) -> bool:
return _BNTypeContainerGetTypeName(container, cstr(typeId), result)
# -------------------------------------------------------
# _BNTypeContainerGetTypeNames
_BNTypeContainerGetTypeNames = core.BNTypeContainerGetTypeNames
_BNTypeContainerGetTypeNames.restype = ctypes.c_bool
_BNTypeContainerGetTypeNames.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeContainerGetTypeNames(
container: ctypes.POINTER(BNTypeContainer),
typeNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeContainerGetTypeNames(container, typeNames, count)
# -------------------------------------------------------
# _BNTypeContainerGetTypeNamesAndIds
_BNTypeContainerGetTypeNamesAndIds = core.BNTypeContainerGetTypeNamesAndIds
_BNTypeContainerGetTypeNamesAndIds.restype = ctypes.c_bool
_BNTypeContainerGetTypeNamesAndIds.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeContainerGetTypeNamesAndIds(
container: ctypes.POINTER(BNTypeContainer),
typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
typeNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeContainerGetTypeNamesAndIds(container, typeIds, typeNames, count)
# -------------------------------------------------------
# _BNTypeContainerGetTypes
_BNTypeContainerGetTypes = core.BNTypeContainerGetTypes
_BNTypeContainerGetTypes.restype = ctypes.c_bool
_BNTypeContainerGetTypes.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(BNType))),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeContainerGetTypes(
container: ctypes.POINTER(BNTypeContainer),
typeIds: ctypes.POINTER(ctypes.POINTER(ctypes.c_char_p)),
typeNames: ctypes.POINTER(ctypes.POINTER(BNQualifiedName)),
types: ctypes.POINTER(ctypes.POINTER(ctypes.POINTER(BNType))),
count: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeContainerGetTypes(container, typeIds, typeNames, types, count)
# -------------------------------------------------------
# _BNTypeContainerIsMutable
_BNTypeContainerIsMutable = core.BNTypeContainerIsMutable
_BNTypeContainerIsMutable.restype = ctypes.c_bool
_BNTypeContainerIsMutable.argtypes = [
ctypes.POINTER(BNTypeContainer),
]
# noinspection PyPep8Naming
def BNTypeContainerIsMutable(
container: ctypes.POINTER(BNTypeContainer)
) -> bool:
return _BNTypeContainerIsMutable(container)
# -------------------------------------------------------
# _BNTypeContainerParseTypeString
_BNTypeContainerParseTypeString = core.BNTypeContainerParseTypeString
_BNTypeContainerParseTypeString.restype = ctypes.c_bool
_BNTypeContainerParseTypeString.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedNameAndType),
ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeContainerParseTypeString(
container: ctypes.POINTER(BNTypeContainer),
source: Optional[str],
result: ctypes.POINTER(BNQualifiedNameAndType),
errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
errorCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeContainerParseTypeString(container, cstr(source), result, errors, errorCount)
# -------------------------------------------------------
# _BNTypeContainerParseTypesFromSource
_BNTypeContainerParseTypesFromSource = core.BNTypeContainerParseTypesFromSource
_BNTypeContainerParseTypesFromSource.restype = ctypes.c_bool
_BNTypeContainerParseTypesFromSource.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.c_char_p,
ctypes.POINTER(BNTypeParserResult),
ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeContainerParseTypesFromSource(
container: ctypes.POINTER(BNTypeContainer),
source: Optional[str],
fileName: Optional[str],
options: ctypes.POINTER(ctypes.c_char_p),
optionCount: int,
includeDirs: ctypes.POINTER(ctypes.c_char_p),
includeDirCount: int,
autoTypeSource: Optional[str],
result: ctypes.POINTER(BNTypeParserResult),
errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
errorCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeContainerParseTypesFromSource(container, cstr(source), cstr(fileName), options, optionCount, includeDirs, includeDirCount, cstr(autoTypeSource), result, errors, errorCount)
# -------------------------------------------------------
# _BNTypeContainerRenameType
_BNTypeContainerRenameType = core.BNTypeContainerRenameType
_BNTypeContainerRenameType.restype = ctypes.c_bool
_BNTypeContainerRenameType.argtypes = [
ctypes.POINTER(BNTypeContainer),
ctypes.c_char_p,
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNTypeContainerRenameType(
container: ctypes.POINTER(BNTypeContainer),
typeId: Optional[str],
newName: ctypes.POINTER(BNQualifiedName)
) -> bool:
return _BNTypeContainerRenameType(container, cstr(typeId), newName)
# -------------------------------------------------------
# _BNTypeGetReferenceType
_BNTypeGetReferenceType = core.BNTypeGetReferenceType
_BNTypeGetReferenceType.restype = ReferenceTypeEnum
_BNTypeGetReferenceType.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNTypeGetReferenceType(
type: ctypes.POINTER(BNType)
) -> ReferenceType:
return _BNTypeGetReferenceType(type)
# -------------------------------------------------------
# _BNTypeGetStructureName
_BNTypeGetStructureName = core.BNTypeGetStructureName
_BNTypeGetStructureName.restype = BNQualifiedName
_BNTypeGetStructureName.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNTypeGetStructureName(
type: ctypes.POINTER(BNType)
) -> BNQualifiedName:
return _BNTypeGetStructureName(type)
# -------------------------------------------------------
# _BNTypeGetSystemCallNumber
_BNTypeGetSystemCallNumber = core.BNTypeGetSystemCallNumber
_BNTypeGetSystemCallNumber.restype = ctypes.c_uint
_BNTypeGetSystemCallNumber.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNTypeGetSystemCallNumber(
type: ctypes.POINTER(BNType)
) -> int:
return _BNTypeGetSystemCallNumber(type)
# -------------------------------------------------------
# _BNTypeGetTypeName
_BNTypeGetTypeName = core.BNTypeGetTypeName
_BNTypeGetTypeName.restype = BNQualifiedName
_BNTypeGetTypeName.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNTypeGetTypeName(
nt: ctypes.POINTER(BNType)
) -> BNQualifiedName:
return _BNTypeGetTypeName(nt)
# -------------------------------------------------------
# _BNTypeHasVariableArguments
_BNTypeHasVariableArguments = core.BNTypeHasVariableArguments
_BNTypeHasVariableArguments.restype = BNBoolWithConfidence
_BNTypeHasVariableArguments.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNTypeHasVariableArguments(
type: ctypes.POINTER(BNType)
) -> BNBoolWithConfidence:
return _BNTypeHasVariableArguments(type)
# -------------------------------------------------------
# _BNTypeIsSystemCall
_BNTypeIsSystemCall = core.BNTypeIsSystemCall
_BNTypeIsSystemCall.restype = ctypes.c_bool
_BNTypeIsSystemCall.argtypes = [
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNTypeIsSystemCall(
type: ctypes.POINTER(BNType)
) -> bool:
return _BNTypeIsSystemCall(type)
# -------------------------------------------------------
# _BNTypeLibraryDecompressToFile
_BNTypeLibraryDecompressToFile = core.BNTypeLibraryDecompressToFile
_BNTypeLibraryDecompressToFile.restype = ctypes.c_bool
_BNTypeLibraryDecompressToFile.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTypeLibraryDecompressToFile(
file: Optional[str],
output: Optional[str]
) -> bool:
return _BNTypeLibraryDecompressToFile(cstr(file), cstr(output))
# -------------------------------------------------------
# _BNTypeLibraryGetMetadata
_BNTypeLibraryGetMetadata = core.BNTypeLibraryGetMetadata
_BNTypeLibraryGetMetadata.restype = ctypes.POINTER(BNMetadata)
_BNTypeLibraryGetMetadata.argtypes = [
ctypes.POINTER(BNTypeLibrary),
]
# noinspection PyPep8Naming
def BNTypeLibraryGetMetadata(
lib: ctypes.POINTER(BNTypeLibrary)
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNTypeLibraryGetMetadata(lib)
if not result:
return None
return result
# -------------------------------------------------------
# _BNTypeLibraryQueryMetadata
_BNTypeLibraryQueryMetadata = core.BNTypeLibraryQueryMetadata
_BNTypeLibraryQueryMetadata.restype = ctypes.POINTER(BNMetadata)
_BNTypeLibraryQueryMetadata.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTypeLibraryQueryMetadata(
lib: ctypes.POINTER(BNTypeLibrary),
key: Optional[str]
) -> Optional[ctypes.POINTER(BNMetadata)]:
result = _BNTypeLibraryQueryMetadata(lib, cstr(key))
if not result:
return None
return result
# -------------------------------------------------------
# _BNTypeLibraryRemoveMetadata
_BNTypeLibraryRemoveMetadata = core.BNTypeLibraryRemoveMetadata
_BNTypeLibraryRemoveMetadata.restype = None
_BNTypeLibraryRemoveMetadata.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNTypeLibraryRemoveMetadata(
lib: ctypes.POINTER(BNTypeLibrary),
key: Optional[str]
) -> None:
return _BNTypeLibraryRemoveMetadata(lib, cstr(key))
# -------------------------------------------------------
# _BNTypeLibraryStoreMetadata
_BNTypeLibraryStoreMetadata = core.BNTypeLibraryStoreMetadata
_BNTypeLibraryStoreMetadata.restype = None
_BNTypeLibraryStoreMetadata.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.c_char_p,
ctypes.POINTER(BNMetadata),
]
# noinspection PyPep8Naming
def BNTypeLibraryStoreMetadata(
lib: ctypes.POINTER(BNTypeLibrary),
key: Optional[str],
value: ctypes.POINTER(BNMetadata)
) -> None:
return _BNTypeLibraryStoreMetadata(lib, cstr(key), value)
# -------------------------------------------------------
# _BNTypeParserParseTypeString
_BNTypeParserParseTypeString = core.BNTypeParserParseTypeString
_BNTypeParserParseTypeString.restype = ctypes.c_bool
_BNTypeParserParseTypeString.argtypes = [
ctypes.POINTER(BNTypeParser),
ctypes.c_char_p,
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNQualifiedNameTypeAndId),
ctypes.c_ulonglong,
ctypes.POINTER(BNQualifiedNameAndType),
ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeParserParseTypeString(
parser: ctypes.POINTER(BNTypeParser),
source: Optional[str],
platform: ctypes.POINTER(BNPlatform),
existingTypes: ctypes.POINTER(BNQualifiedNameTypeAndId),
existingTypeCount: int,
result: ctypes.POINTER(BNQualifiedNameAndType),
errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
errorCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeParserParseTypeString(parser, cstr(source), platform, existingTypes, existingTypeCount, result, errors, errorCount)
# -------------------------------------------------------
# _BNTypeParserParseTypesFromSource
_BNTypeParserParseTypesFromSource = core.BNTypeParserParseTypesFromSource
_BNTypeParserParseTypesFromSource.restype = ctypes.c_bool
_BNTypeParserParseTypesFromSource.argtypes = [
ctypes.POINTER(BNTypeParser),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNQualifiedNameTypeAndId),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.c_char_p,
ctypes.POINTER(BNTypeParserResult),
ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeParserParseTypesFromSource(
parser: ctypes.POINTER(BNTypeParser),
source: Optional[str],
fileName: Optional[str],
platform: ctypes.POINTER(BNPlatform),
existingTypes: ctypes.POINTER(BNQualifiedNameTypeAndId),
existingTypeCount: int,
options: ctypes.POINTER(ctypes.c_char_p),
optionCount: int,
includeDirs: ctypes.POINTER(ctypes.c_char_p),
includeDirCount: int,
autoTypeSource: Optional[str],
result: ctypes.POINTER(BNTypeParserResult),
errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
errorCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeParserParseTypesFromSource(parser, cstr(source), cstr(fileName), platform, existingTypes, existingTypeCount, options, optionCount, includeDirs, includeDirCount, cstr(autoTypeSource), result, errors, errorCount)
# -------------------------------------------------------
# _BNTypeParserPreprocessSource
_BNTypeParserPreprocessSource = core.BNTypeParserPreprocessSource
_BNTypeParserPreprocessSource.restype = ctypes.c_bool
_BNTypeParserPreprocessSource.argtypes = [
ctypes.POINTER(BNTypeParser),
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(BNPlatform),
ctypes.POINTER(BNQualifiedNameTypeAndId),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
ctypes.POINTER(ctypes.c_char_p),
ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNTypeParserPreprocessSource(
parser: ctypes.POINTER(BNTypeParser),
source: Optional[str],
fileName: Optional[str],
platform: ctypes.POINTER(BNPlatform),
existingTypes: ctypes.POINTER(BNQualifiedNameTypeAndId),
existingTypeCount: int,
options: ctypes.POINTER(ctypes.c_char_p),
optionCount: int,
includeDirs: ctypes.POINTER(ctypes.c_char_p),
includeDirCount: int,
output: ctypes.POINTER(ctypes.c_char_p),
errors: ctypes.POINTER(ctypes.POINTER(BNTypeParserError)),
errorCount: ctypes.POINTER(ctypes.c_ulonglong)
) -> bool:
return _BNTypeParserPreprocessSource(parser, cstr(source), cstr(fileName), platform, existingTypes, existingTypeCount, options, optionCount, includeDirs, includeDirCount, output, errors, errorCount)
# -------------------------------------------------------
# _BNTypePrinterDefaultPrintAllTypes
_BNTypePrinterDefaultPrintAllTypes = core.BNTypePrinterDefaultPrintAllTypes
_BNTypePrinterDefaultPrintAllTypes.restype = ctypes.c_bool
_BNTypePrinterDefaultPrintAllTypes.argtypes = [
ctypes.POINTER(BNTypePrinter),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.c_ulonglong,
ctypes.POINTER(BNBinaryView),
ctypes.c_int,
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNTypePrinterDefaultPrintAllTypes(
printer: ctypes.POINTER(BNTypePrinter),
names: ctypes.POINTER(BNQualifiedName),
types: ctypes.POINTER(ctypes.POINTER(BNType)),
typeCount: int,
data: ctypes.POINTER(BNBinaryView),
lineWidth: int,
escaping: TokenEscapingType,
result: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNTypePrinterDefaultPrintAllTypes(printer, names, types, typeCount, data, lineWidth, escaping, result)
# -------------------------------------------------------
# _BNTypePrinterPrintAllTypes
_BNTypePrinterPrintAllTypes = core.BNTypePrinterPrintAllTypes
_BNTypePrinterPrintAllTypes.restype = ctypes.c_bool
_BNTypePrinterPrintAllTypes.argtypes = [
ctypes.POINTER(BNTypePrinter),
ctypes.POINTER(BNQualifiedName),
ctypes.POINTER(ctypes.POINTER(BNType)),
ctypes.c_ulonglong,
ctypes.POINTER(BNBinaryView),
ctypes.c_int,
TokenEscapingTypeEnum,
ctypes.POINTER(ctypes.c_char_p),
]
# noinspection PyPep8Naming
def BNTypePrinterPrintAllTypes(
printer: ctypes.POINTER(BNTypePrinter),
names: ctypes.POINTER(BNQualifiedName),
types: ctypes.POINTER(ctypes.POINTER(BNType)),
typeCount: int,
data: ctypes.POINTER(BNBinaryView),
lineWidth: int,
escaping: TokenEscapingType,
result: ctypes.POINTER(ctypes.c_char_p)
) -> bool:
return _BNTypePrinterPrintAllTypes(printer, names, types, typeCount, data, lineWidth, escaping, result)
# -------------------------------------------------------
# _BNTypeWithReplacedEnumeration
_BNTypeWithReplacedEnumeration = core.BNTypeWithReplacedEnumeration
_BNTypeWithReplacedEnumeration.restype = ctypes.POINTER(BNType)
_BNTypeWithReplacedEnumeration.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNEnumeration),
ctypes.POINTER(BNEnumeration),
]
# noinspection PyPep8Naming
def BNTypeWithReplacedEnumeration(
type: ctypes.POINTER(BNType),
from_: ctypes.POINTER(BNEnumeration),
to: ctypes.POINTER(BNEnumeration)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNTypeWithReplacedEnumeration(type, from_, to)
if not result:
return None
return result
# -------------------------------------------------------
# _BNTypeWithReplacedNamedTypeReference
_BNTypeWithReplacedNamedTypeReference = core.BNTypeWithReplacedNamedTypeReference
_BNTypeWithReplacedNamedTypeReference.restype = ctypes.POINTER(BNType)
_BNTypeWithReplacedNamedTypeReference.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNNamedTypeReference),
ctypes.POINTER(BNNamedTypeReference),
]
# noinspection PyPep8Naming
def BNTypeWithReplacedNamedTypeReference(
type: ctypes.POINTER(BNType),
from_: ctypes.POINTER(BNNamedTypeReference),
to: ctypes.POINTER(BNNamedTypeReference)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNTypeWithReplacedNamedTypeReference(type, from_, to)
if not result:
return None
return result
# -------------------------------------------------------
# _BNTypeWithReplacedStructure
_BNTypeWithReplacedStructure = core.BNTypeWithReplacedStructure
_BNTypeWithReplacedStructure.restype = ctypes.POINTER(BNType)
_BNTypeWithReplacedStructure.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNStructure),
ctypes.POINTER(BNStructure),
]
# noinspection PyPep8Naming
def BNTypeWithReplacedStructure(
type: ctypes.POINTER(BNType),
from_: ctypes.POINTER(BNStructure),
to: ctypes.POINTER(BNStructure)
) -> Optional[ctypes.POINTER(BNType)]:
result = _BNTypeWithReplacedStructure(type, from_, to)
if not result:
return None
return result
# -------------------------------------------------------
# _BNTypesEqual
_BNTypesEqual = core.BNTypesEqual
_BNTypesEqual.restype = ctypes.c_bool
_BNTypesEqual.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNTypesEqual(
a: ctypes.POINTER(BNType),
b: ctypes.POINTER(BNType)
) -> bool:
return _BNTypesEqual(a, b)
# -------------------------------------------------------
# _BNTypesNotEqual
_BNTypesNotEqual = core.BNTypesNotEqual
_BNTypesNotEqual.restype = ctypes.c_bool
_BNTypesNotEqual.argtypes = [
ctypes.POINTER(BNType),
ctypes.POINTER(BNType),
]
# noinspection PyPep8Naming
def BNTypesNotEqual(
a: ctypes.POINTER(BNType),
b: ctypes.POINTER(BNType)
) -> bool:
return _BNTypesNotEqual(a, b)
# -------------------------------------------------------
# _BNUndefineAnalysisType
_BNUndefineAnalysisType = core.BNUndefineAnalysisType
_BNUndefineAnalysisType.restype = None
_BNUndefineAnalysisType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNUndefineAnalysisType(
view: ctypes.POINTER(BNBinaryView),
id: Optional[str]
) -> None:
return _BNUndefineAnalysisType(view, cstr(id))
# -------------------------------------------------------
# _BNUndefineAutoSymbol
_BNUndefineAutoSymbol = core.BNUndefineAutoSymbol
_BNUndefineAutoSymbol.restype = None
_BNUndefineAutoSymbol.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNUndefineAutoSymbol(
view: ctypes.POINTER(BNBinaryView),
sym: ctypes.POINTER(BNSymbol)
) -> None:
return _BNUndefineAutoSymbol(view, sym)
# -------------------------------------------------------
# _BNUndefineDataVariable
_BNUndefineDataVariable = core.BNUndefineDataVariable
_BNUndefineDataVariable.restype = None
_BNUndefineDataVariable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNUndefineDataVariable(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> None:
return _BNUndefineDataVariable(view, addr)
# -------------------------------------------------------
# _BNUndefineUserAnalysisType
_BNUndefineUserAnalysisType = core.BNUndefineUserAnalysisType
_BNUndefineUserAnalysisType.restype = None
_BNUndefineUserAnalysisType.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNQualifiedName),
]
# noinspection PyPep8Naming
def BNUndefineUserAnalysisType(
view: ctypes.POINTER(BNBinaryView),
name: ctypes.POINTER(BNQualifiedName)
) -> None:
return _BNUndefineUserAnalysisType(view, name)
# -------------------------------------------------------
# _BNUndefineUserDataVariable
_BNUndefineUserDataVariable = core.BNUndefineUserDataVariable
_BNUndefineUserDataVariable.restype = None
_BNUndefineUserDataVariable.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNUndefineUserDataVariable(
view: ctypes.POINTER(BNBinaryView),
addr: int
) -> None:
return _BNUndefineUserDataVariable(view, addr)
# -------------------------------------------------------
# _BNUndefineUserSymbol
_BNUndefineUserSymbol = core.BNUndefineUserSymbol
_BNUndefineUserSymbol.restype = None
_BNUndefineUserSymbol.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNSymbol),
]
# noinspection PyPep8Naming
def BNUndefineUserSymbol(
view: ctypes.POINTER(BNBinaryView),
sym: ctypes.POINTER(BNSymbol)
) -> None:
return _BNUndefineUserSymbol(view, sym)
# -------------------------------------------------------
# _BNUndo
_BNUndo = core.BNUndo
_BNUndo.restype = ctypes.c_bool
_BNUndo.argtypes = [
ctypes.POINTER(BNFileMetadata),
]
# noinspection PyPep8Naming
def BNUndo(
file: ctypes.POINTER(BNFileMetadata)
) -> bool:
return _BNUndo(file)
# -------------------------------------------------------
# _BNUnescapeTypeName
_BNUnescapeTypeName = core.BNUnescapeTypeName
_BNUnescapeTypeName.restype = ctypes.POINTER(ctypes.c_byte)
_BNUnescapeTypeName.argtypes = [
ctypes.c_char_p,
TokenEscapingTypeEnum,
]
# noinspection PyPep8Naming
def BNUnescapeTypeName(
name: Optional[str],
escaping: TokenEscapingType
) -> Optional[Optional[str]]:
result = _BNUnescapeTypeName(cstr(name), escaping)
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNUnmergeVariables
_BNUnmergeVariables = core.BNUnmergeVariables
_BNUnmergeVariables.restype = None
_BNUnmergeVariables.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
ctypes.POINTER(BNVariable),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNUnmergeVariables(
func: ctypes.POINTER(BNFunction),
target: ctypes.POINTER(BNVariable),
sources: ctypes.POINTER(BNVariable),
sourceCount: int
) -> None:
return _BNUnmergeVariables(func, target, sources, sourceCount)
# -------------------------------------------------------
# _BNUnregisterDataNotification
_BNUnregisterDataNotification = core.BNUnregisterDataNotification
_BNUnregisterDataNotification.restype = None
_BNUnregisterDataNotification.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.POINTER(BNBinaryDataNotification),
]
# noinspection PyPep8Naming
def BNUnregisterDataNotification(
view: ctypes.POINTER(BNBinaryView),
notify: ctypes.POINTER(BNBinaryDataNotification)
) -> None:
return _BNUnregisterDataNotification(view, notify)
# -------------------------------------------------------
# _BNUnregisterDebugInfoParser
_BNUnregisterDebugInfoParser = core.BNUnregisterDebugInfoParser
_BNUnregisterDebugInfoParser.restype = None
_BNUnregisterDebugInfoParser.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNUnregisterDebugInfoParser(
rawName: Optional[str]
) -> None:
return _BNUnregisterDebugInfoParser(cstr(rawName))
# -------------------------------------------------------
# _BNUnregisterEnterpriseServerNotification
_BNUnregisterEnterpriseServerNotification = core.BNUnregisterEnterpriseServerNotification
_BNUnregisterEnterpriseServerNotification.restype = None
_BNUnregisterEnterpriseServerNotification.argtypes = [
ctypes.POINTER(BNEnterpriseServerCallbacks),
]
# noinspection PyPep8Naming
def BNUnregisterEnterpriseServerNotification(
notify: ctypes.POINTER(BNEnterpriseServerCallbacks)
) -> None:
return _BNUnregisterEnterpriseServerNotification(notify)
# -------------------------------------------------------
# _BNUnregisterLogListener
_BNUnregisterLogListener = core.BNUnregisterLogListener
_BNUnregisterLogListener.restype = None
_BNUnregisterLogListener.argtypes = [
ctypes.POINTER(BNLogListener),
]
# noinspection PyPep8Naming
def BNUnregisterLogListener(
listener: ctypes.POINTER(BNLogListener)
) -> None:
return _BNUnregisterLogListener(listener)
# -------------------------------------------------------
# _BNUnregisterObjectDestructionCallbacks
_BNUnregisterObjectDestructionCallbacks = core.BNUnregisterObjectDestructionCallbacks
_BNUnregisterObjectDestructionCallbacks.restype = None
_BNUnregisterObjectDestructionCallbacks.argtypes = [
ctypes.POINTER(BNObjectDestructionCallbacks),
]
# noinspection PyPep8Naming
def BNUnregisterObjectDestructionCallbacks(
callbacks: ctypes.POINTER(BNObjectDestructionCallbacks)
) -> None:
return _BNUnregisterObjectDestructionCallbacks(callbacks)
# -------------------------------------------------------
# _BNUnregisterObjectRefDebugTrace
_BNUnregisterObjectRefDebugTrace = core.BNUnregisterObjectRefDebugTrace
_BNUnregisterObjectRefDebugTrace.restype = None
_BNUnregisterObjectRefDebugTrace.argtypes = [
ctypes.c_char_p,
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNUnregisterObjectRefDebugTrace(
typeName: Optional[str],
trace: Optional[ctypes.c_void_p]
) -> None:
return _BNUnregisterObjectRefDebugTrace(cstr(typeName), trace)
# -------------------------------------------------------
# _BNUnregisterProjectNotification
_BNUnregisterProjectNotification = core.BNUnregisterProjectNotification
_BNUnregisterProjectNotification.restype = None
_BNUnregisterProjectNotification.argtypes = [
ctypes.POINTER(BNProject),
ctypes.POINTER(BNProjectNotification),
]
# noinspection PyPep8Naming
def BNUnregisterProjectNotification(
project: ctypes.POINTER(BNProject),
notify: ctypes.POINTER(BNProjectNotification)
) -> None:
return _BNUnregisterProjectNotification(project, notify)
# -------------------------------------------------------
# _BNUnregisterScriptingInstanceOutputListener
_BNUnregisterScriptingInstanceOutputListener = core.BNUnregisterScriptingInstanceOutputListener
_BNUnregisterScriptingInstanceOutputListener.restype = None
_BNUnregisterScriptingInstanceOutputListener.argtypes = [
ctypes.POINTER(BNScriptingInstance),
ctypes.POINTER(BNScriptingOutputListener),
]
# noinspection PyPep8Naming
def BNUnregisterScriptingInstanceOutputListener(
instance: ctypes.POINTER(BNScriptingInstance),
callbacks: ctypes.POINTER(BNScriptingOutputListener)
) -> None:
return _BNUnregisterScriptingInstanceOutputListener(instance, callbacks)
# -------------------------------------------------------
# _BNUnregisterTypeArchiveNotification
_BNUnregisterTypeArchiveNotification = core.BNUnregisterTypeArchiveNotification
_BNUnregisterTypeArchiveNotification.restype = None
_BNUnregisterTypeArchiveNotification.argtypes = [
ctypes.POINTER(BNTypeArchive),
ctypes.POINTER(BNTypeArchiveNotification),
]
# noinspection PyPep8Naming
def BNUnregisterTypeArchiveNotification(
archive: ctypes.POINTER(BNTypeArchive),
notification: ctypes.POINTER(BNTypeArchiveNotification)
) -> None:
return _BNUnregisterTypeArchiveNotification(archive, notification)
# -------------------------------------------------------
# _BNUnregisterViewOfType
_BNUnregisterViewOfType = core.BNUnregisterViewOfType
_BNUnregisterViewOfType.restype = None
_BNUnregisterViewOfType.argtypes = [
ctypes.POINTER(BNFileMetadata),
ctypes.c_char_p,
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNUnregisterViewOfType(
file: ctypes.POINTER(BNFileMetadata),
type: Optional[str],
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNUnregisterViewOfType(file, cstr(type), view)
# -------------------------------------------------------
# _BNUnsplitVariable
_BNUnsplitVariable = core.BNUnsplitVariable
_BNUnsplitVariable.restype = None
_BNUnsplitVariable.argtypes = [
ctypes.POINTER(BNFunction),
ctypes.POINTER(BNVariable),
]
# noinspection PyPep8Naming
def BNUnsplitVariable(
func: ctypes.POINTER(BNFunction),
var: ctypes.POINTER(BNVariable)
) -> None:
return _BNUnsplitVariable(func, var)
# -------------------------------------------------------
# _BNUpdateAnalysis
_BNUpdateAnalysis = core.BNUpdateAnalysis
_BNUpdateAnalysis.restype = None
_BNUpdateAnalysis.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNUpdateAnalysis(
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNUpdateAnalysis(view)
# -------------------------------------------------------
# _BNUpdateAnalysisAndWait
_BNUpdateAnalysisAndWait = core.BNUpdateAnalysisAndWait
_BNUpdateAnalysisAndWait.restype = None
_BNUpdateAnalysisAndWait.argtypes = [
ctypes.POINTER(BNBinaryView),
]
# noinspection PyPep8Naming
def BNUpdateAnalysisAndWait(
view: ctypes.POINTER(BNBinaryView)
) -> None:
return _BNUpdateAnalysisAndWait(view)
# -------------------------------------------------------
# _BNUpdateEnterpriseServerLicense
_BNUpdateEnterpriseServerLicense = core.BNUpdateEnterpriseServerLicense
_BNUpdateEnterpriseServerLicense.restype = ctypes.c_bool
_BNUpdateEnterpriseServerLicense.argtypes = [
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNUpdateEnterpriseServerLicense(
timeout: int
) -> bool:
return _BNUpdateEnterpriseServerLicense(timeout)
# -------------------------------------------------------
# _BNUpdateFlowGraph
_BNUpdateFlowGraph = core.BNUpdateFlowGraph
_BNUpdateFlowGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNUpdateFlowGraph.argtypes = [
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNUpdateFlowGraph(
graph: ctypes.POINTER(BNFlowGraph)
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNUpdateFlowGraph(graph)
if not result:
return None
return result
# -------------------------------------------------------
# _BNUpdateHighLevelILOperand
_BNUpdateHighLevelILOperand = core.BNUpdateHighLevelILOperand
_BNUpdateHighLevelILOperand.restype = None
_BNUpdateHighLevelILOperand.argtypes = [
ctypes.POINTER(BNHighLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNUpdateHighLevelILOperand(
func: ctypes.POINTER(BNHighLevelILFunction),
instr: int,
operandIndex: int,
value: int
) -> None:
return _BNUpdateHighLevelILOperand(func, instr, operandIndex, value)
# -------------------------------------------------------
# _BNUpdateLogListeners
_BNUpdateLogListeners = core.BNUpdateLogListeners
_BNUpdateLogListeners.restype = None
_BNUpdateLogListeners.argtypes = [
]
# noinspection PyPep8Naming
def BNUpdateLogListeners(
) -> None:
return _BNUpdateLogListeners()
# -------------------------------------------------------
# _BNUpdateLowLevelILOperand
_BNUpdateLowLevelILOperand = core.BNUpdateLowLevelILOperand
_BNUpdateLowLevelILOperand.restype = None
_BNUpdateLowLevelILOperand.argtypes = [
ctypes.POINTER(BNLowLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNUpdateLowLevelILOperand(
func: ctypes.POINTER(BNLowLevelILFunction),
instr: int,
operandIndex: int,
value: int
) -> None:
return _BNUpdateLowLevelILOperand(func, instr, operandIndex, value)
# -------------------------------------------------------
# _BNUpdateMediumLevelILOperand
_BNUpdateMediumLevelILOperand = core.BNUpdateMediumLevelILOperand
_BNUpdateMediumLevelILOperand.restype = None
_BNUpdateMediumLevelILOperand.argtypes = [
ctypes.POINTER(BNMediumLevelILFunction),
ctypes.c_ulonglong,
ctypes.c_ulonglong,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNUpdateMediumLevelILOperand(
func: ctypes.POINTER(BNMediumLevelILFunction),
instr: int,
operandIndex: int,
value: int
) -> None:
return _BNUpdateMediumLevelILOperand(func, instr, operandIndex, value)
# -------------------------------------------------------
# _BNUpdateReportFlowGraph
_BNUpdateReportFlowGraph = core.BNUpdateReportFlowGraph
_BNUpdateReportFlowGraph.restype = None
_BNUpdateReportFlowGraph.argtypes = [
ctypes.POINTER(BNReportCollection),
ctypes.c_ulonglong,
ctypes.POINTER(BNFlowGraph),
]
# noinspection PyPep8Naming
def BNUpdateReportFlowGraph(
reports: ctypes.POINTER(BNReportCollection),
i: int,
graph: ctypes.POINTER(BNFlowGraph)
) -> None:
return _BNUpdateReportFlowGraph(reports, i, graph)
# -------------------------------------------------------
# _BNUpdateToLatestVersion
_BNUpdateToLatestVersion = core.BNUpdateToLatestVersion
_BNUpdateToLatestVersion.restype = UpdateResultEnum
_BNUpdateToLatestVersion.argtypes = [
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNUpdateToLatestVersion(
channel: Optional[str],
errors: ctypes.POINTER(ctypes.c_char_p),
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
context: Optional[ctypes.c_void_p]
) -> UpdateResult:
return _BNUpdateToLatestVersion(cstr(channel), errors, progress, context)
# -------------------------------------------------------
# _BNUpdateToVersion
_BNUpdateToVersion = core.BNUpdateToVersion
_BNUpdateToVersion.restype = UpdateResultEnum
_BNUpdateToVersion.argtypes = [
ctypes.c_char_p,
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
ctypes.c_void_p,
]
# noinspection PyPep8Naming
def BNUpdateToVersion(
channel: Optional[str],
version: Optional[str],
errors: ctypes.POINTER(ctypes.c_char_p),
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
context: Optional[ctypes.c_void_p]
) -> UpdateResult:
return _BNUpdateToVersion(cstr(channel), cstr(version), errors, progress, context)
# -------------------------------------------------------
# _BNUpdatesChecked
_BNUpdatesChecked = core.BNUpdatesChecked
_BNUpdatesChecked.restype = None
_BNUpdatesChecked.argtypes = [
]
# noinspection PyPep8Naming
def BNUpdatesChecked(
) -> None:
return _BNUpdatesChecked()
# -------------------------------------------------------
# _BNWaitForMainThreadAction
_BNWaitForMainThreadAction = core.BNWaitForMainThreadAction
_BNWaitForMainThreadAction.restype = None
_BNWaitForMainThreadAction.argtypes = [
ctypes.POINTER(BNMainThreadAction),
]
# noinspection PyPep8Naming
def BNWaitForMainThreadAction(
action: ctypes.POINTER(BNMainThreadAction)
) -> None:
return _BNWaitForMainThreadAction(action)
# -------------------------------------------------------
# _BNWasFunctionAutomaticallyDiscovered
_BNWasFunctionAutomaticallyDiscovered = core.BNWasFunctionAutomaticallyDiscovered
_BNWasFunctionAutomaticallyDiscovered.restype = ctypes.c_bool
_BNWasFunctionAutomaticallyDiscovered.argtypes = [
ctypes.POINTER(BNFunction),
]
# noinspection PyPep8Naming
def BNWasFunctionAutomaticallyDiscovered(
func: ctypes.POINTER(BNFunction)
) -> bool:
return _BNWasFunctionAutomaticallyDiscovered(func)
# -------------------------------------------------------
# _BNWorkerEnqueue
_BNWorkerEnqueue = core.BNWorkerEnqueue
_BNWorkerEnqueue.restype = None
_BNWorkerEnqueue.argtypes = [
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
]
# noinspection PyPep8Naming
def BNWorkerEnqueue(
ctxt: Optional[ctypes.c_void_p],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
) -> None:
return _BNWorkerEnqueue(ctxt, action)
# -------------------------------------------------------
# _BNWorkerEnqueueNamed
_BNWorkerEnqueueNamed = core.BNWorkerEnqueueNamed
_BNWorkerEnqueueNamed.restype = None
_BNWorkerEnqueueNamed.argtypes = [
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkerEnqueueNamed(
ctxt: Optional[ctypes.c_void_p],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p),
name: Optional[str]
) -> None:
return _BNWorkerEnqueueNamed(ctxt, action, cstr(name))
# -------------------------------------------------------
# _BNWorkerInteractiveEnqueue
_BNWorkerInteractiveEnqueue = core.BNWorkerInteractiveEnqueue
_BNWorkerInteractiveEnqueue.restype = None
_BNWorkerInteractiveEnqueue.argtypes = [
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
]
# noinspection PyPep8Naming
def BNWorkerInteractiveEnqueue(
ctxt: Optional[ctypes.c_void_p],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
) -> None:
return _BNWorkerInteractiveEnqueue(ctxt, action)
# -------------------------------------------------------
# _BNWorkerInteractiveEnqueueNamed
_BNWorkerInteractiveEnqueueNamed = core.BNWorkerInteractiveEnqueueNamed
_BNWorkerInteractiveEnqueueNamed.restype = None
_BNWorkerInteractiveEnqueueNamed.argtypes = [
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkerInteractiveEnqueueNamed(
ctxt: Optional[ctypes.c_void_p],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p),
name: Optional[str]
) -> None:
return _BNWorkerInteractiveEnqueueNamed(ctxt, action, cstr(name))
# -------------------------------------------------------
# _BNWorkerPriorityEnqueue
_BNWorkerPriorityEnqueue = core.BNWorkerPriorityEnqueue
_BNWorkerPriorityEnqueue.restype = None
_BNWorkerPriorityEnqueue.argtypes = [
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
]
# noinspection PyPep8Naming
def BNWorkerPriorityEnqueue(
ctxt: Optional[ctypes.c_void_p],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p)
) -> None:
return _BNWorkerPriorityEnqueue(ctxt, action)
# -------------------------------------------------------
# _BNWorkerPriorityEnqueueNamed
_BNWorkerPriorityEnqueueNamed = core.BNWorkerPriorityEnqueueNamed
_BNWorkerPriorityEnqueueNamed.restype = None
_BNWorkerPriorityEnqueueNamed.argtypes = [
ctypes.c_void_p,
ctypes.CFUNCTYPE(None, ctypes.c_void_p),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkerPriorityEnqueueNamed(
ctxt: Optional[ctypes.c_void_p],
action: ctypes.CFUNCTYPE(None, ctypes.c_void_p),
name: Optional[str]
) -> None:
return _BNWorkerPriorityEnqueueNamed(ctxt, action, cstr(name))
# -------------------------------------------------------
# _BNWorkflowAssignSubactivities
_BNWorkflowAssignSubactivities = core.BNWorkflowAssignSubactivities
_BNWorkflowAssignSubactivities.restype = ctypes.c_bool
_BNWorkflowAssignSubactivities.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWorkflowAssignSubactivities(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str],
activities: ctypes.POINTER(ctypes.c_char_p),
size: int
) -> bool:
return _BNWorkflowAssignSubactivities(workflow, cstr(activity), activities, size)
# -------------------------------------------------------
# _BNWorkflowClear
_BNWorkflowClear = core.BNWorkflowClear
_BNWorkflowClear.restype = ctypes.c_bool
_BNWorkflowClear.argtypes = [
ctypes.POINTER(BNWorkflow),
]
# noinspection PyPep8Naming
def BNWorkflowClear(
workflow: ctypes.POINTER(BNWorkflow)
) -> bool:
return _BNWorkflowClear(workflow)
# -------------------------------------------------------
# _BNWorkflowClone
_BNWorkflowClone = core.BNWorkflowClone
_BNWorkflowClone.restype = ctypes.POINTER(BNWorkflow)
_BNWorkflowClone.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkflowClone(
workflow: ctypes.POINTER(BNWorkflow),
name: Optional[str],
activity: Optional[str]
) -> Optional[ctypes.POINTER(BNWorkflow)]:
result = _BNWorkflowClone(workflow, cstr(name), cstr(activity))
if not result:
return None
return result
# -------------------------------------------------------
# _BNWorkflowContains
_BNWorkflowContains = core.BNWorkflowContains
_BNWorkflowContains.restype = ctypes.c_bool
_BNWorkflowContains.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkflowContains(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str]
) -> bool:
return _BNWorkflowContains(workflow, cstr(activity))
# -------------------------------------------------------
# _BNWorkflowGetActivity
_BNWorkflowGetActivity = core.BNWorkflowGetActivity
_BNWorkflowGetActivity.restype = ctypes.POINTER(BNActivity)
_BNWorkflowGetActivity.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkflowGetActivity(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str]
) -> Optional[ctypes.POINTER(BNActivity)]:
result = _BNWorkflowGetActivity(workflow, cstr(activity))
if not result:
return None
return result
# -------------------------------------------------------
# _BNWorkflowGetActivityRoots
_BNWorkflowGetActivityRoots = core.BNWorkflowGetActivityRoots
_BNWorkflowGetActivityRoots.restype = ctypes.POINTER(ctypes.c_char_p)
_BNWorkflowGetActivityRoots.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNWorkflowGetActivityRoots(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str],
inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNWorkflowGetActivityRoots(workflow, cstr(activity), inoutSize)
if not result:
return None
return result
# -------------------------------------------------------
# _BNWorkflowGetConfiguration
_BNWorkflowGetConfiguration = core.BNWorkflowGetConfiguration
_BNWorkflowGetConfiguration.restype = ctypes.POINTER(ctypes.c_byte)
_BNWorkflowGetConfiguration.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkflowGetConfiguration(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str]
) -> Optional[Optional[str]]:
result = _BNWorkflowGetConfiguration(workflow, cstr(activity))
string = str(pyNativeStr(ctypes.cast(result, ctypes.c_char_p).value))
BNFreeString(result)
return string
# -------------------------------------------------------
# _BNWorkflowGetGraph
_BNWorkflowGetGraph = core.BNWorkflowGetGraph
_BNWorkflowGetGraph.restype = ctypes.POINTER(BNFlowGraph)
_BNWorkflowGetGraph.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
ctypes.c_bool,
]
# noinspection PyPep8Naming
def BNWorkflowGetGraph(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str],
sequential: bool
) -> Optional[ctypes.POINTER(BNFlowGraph)]:
result = _BNWorkflowGetGraph(workflow, cstr(activity), sequential)
if not result:
return None
return result
# -------------------------------------------------------
# _BNWorkflowGetSubactivities
_BNWorkflowGetSubactivities = core.BNWorkflowGetSubactivities
_BNWorkflowGetSubactivities.restype = ctypes.POINTER(ctypes.c_char_p)
_BNWorkflowGetSubactivities.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
ctypes.c_bool,
ctypes.POINTER(ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNWorkflowGetSubactivities(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str],
immediate: bool,
inoutSize: ctypes.POINTER(ctypes.c_ulonglong)
) -> Optional[ctypes.POINTER(ctypes.c_char_p)]:
result = _BNWorkflowGetSubactivities(workflow, cstr(activity), immediate, inoutSize)
if not result:
return None
return result
# -------------------------------------------------------
# _BNWorkflowInsert
_BNWorkflowInsert = core.BNWorkflowInsert
_BNWorkflowInsert.restype = ctypes.c_bool
_BNWorkflowInsert.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWorkflowInsert(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str],
activities: ctypes.POINTER(ctypes.c_char_p),
size: int
) -> bool:
return _BNWorkflowInsert(workflow, cstr(activity), activities, size)
# -------------------------------------------------------
# _BNWorkflowInstance
_BNWorkflowInstance = core.BNWorkflowInstance
_BNWorkflowInstance.restype = ctypes.POINTER(BNWorkflow)
_BNWorkflowInstance.argtypes = [
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkflowInstance(
name: Optional[str]
) -> Optional[ctypes.POINTER(BNWorkflow)]:
result = _BNWorkflowInstance(cstr(name))
if not result:
return None
return result
# -------------------------------------------------------
# _BNWorkflowIsRegistered
_BNWorkflowIsRegistered = core.BNWorkflowIsRegistered
_BNWorkflowIsRegistered.restype = ctypes.c_bool
_BNWorkflowIsRegistered.argtypes = [
ctypes.POINTER(BNWorkflow),
]
# noinspection PyPep8Naming
def BNWorkflowIsRegistered(
workflow: ctypes.POINTER(BNWorkflow)
) -> bool:
return _BNWorkflowIsRegistered(workflow)
# -------------------------------------------------------
# _BNWorkflowRegisterActivity
_BNWorkflowRegisterActivity = core.BNWorkflowRegisterActivity
_BNWorkflowRegisterActivity.restype = ctypes.POINTER(BNActivity)
_BNWorkflowRegisterActivity.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.POINTER(BNActivity),
ctypes.POINTER(ctypes.c_char_p),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWorkflowRegisterActivity(
workflow: ctypes.POINTER(BNWorkflow),
activity: ctypes.POINTER(BNActivity),
subactivities: ctypes.POINTER(ctypes.c_char_p),
size: int
) -> Optional[ctypes.POINTER(BNActivity)]:
result = _BNWorkflowRegisterActivity(workflow, activity, subactivities, size)
if not result:
return None
return result
# -------------------------------------------------------
# _BNWorkflowRemove
_BNWorkflowRemove = core.BNWorkflowRemove
_BNWorkflowRemove.restype = ctypes.c_bool
_BNWorkflowRemove.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkflowRemove(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str]
) -> bool:
return _BNWorkflowRemove(workflow, cstr(activity))
# -------------------------------------------------------
# _BNWorkflowReplace
_BNWorkflowReplace = core.BNWorkflowReplace
_BNWorkflowReplace.restype = ctypes.c_bool
_BNWorkflowReplace.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkflowReplace(
workflow: ctypes.POINTER(BNWorkflow),
activity: Optional[str],
newActivity: Optional[str]
) -> bool:
return _BNWorkflowReplace(workflow, cstr(activity), cstr(newActivity))
# -------------------------------------------------------
# _BNWorkflowShowReport
_BNWorkflowShowReport = core.BNWorkflowShowReport
_BNWorkflowShowReport.restype = None
_BNWorkflowShowReport.argtypes = [
ctypes.POINTER(BNWorkflow),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWorkflowShowReport(
workflow: ctypes.POINTER(BNWorkflow),
name: Optional[str]
) -> None:
return _BNWorkflowShowReport(workflow, cstr(name))
# -------------------------------------------------------
# _BNWorkflowSize
_BNWorkflowSize = core.BNWorkflowSize
_BNWorkflowSize.restype = ctypes.c_ulonglong
_BNWorkflowSize.argtypes = [
ctypes.POINTER(BNWorkflow),
]
# noinspection PyPep8Naming
def BNWorkflowSize(
workflow: ctypes.POINTER(BNWorkflow)
) -> int:
return _BNWorkflowSize(workflow)
# -------------------------------------------------------
# _BNWrite16
_BNWrite16 = core.BNWrite16
_BNWrite16.restype = ctypes.c_bool
_BNWrite16.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_ushort,
]
# noinspection PyPep8Naming
def BNWrite16(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWrite16(stream, val)
# -------------------------------------------------------
# _BNWrite32
_BNWrite32 = core.BNWrite32
_BNWrite32.restype = ctypes.c_bool
_BNWrite32.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNWrite32(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWrite32(stream, val)
# -------------------------------------------------------
# _BNWrite64
_BNWrite64 = core.BNWrite64
_BNWrite64.restype = ctypes.c_bool
_BNWrite64.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWrite64(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWrite64(stream, val)
# -------------------------------------------------------
# _BNWrite8
_BNWrite8 = core.BNWrite8
_BNWrite8.restype = ctypes.c_bool
_BNWrite8.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_ubyte,
]
# noinspection PyPep8Naming
def BNWrite8(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWrite8(stream, val)
# -------------------------------------------------------
# _BNWriteBE16
_BNWriteBE16 = core.BNWriteBE16
_BNWriteBE16.restype = ctypes.c_bool
_BNWriteBE16.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_ushort,
]
# noinspection PyPep8Naming
def BNWriteBE16(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWriteBE16(stream, val)
# -------------------------------------------------------
# _BNWriteBE32
_BNWriteBE32 = core.BNWriteBE32
_BNWriteBE32.restype = ctypes.c_bool
_BNWriteBE32.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNWriteBE32(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWriteBE32(stream, val)
# -------------------------------------------------------
# _BNWriteBE64
_BNWriteBE64 = core.BNWriteBE64
_BNWriteBE64.restype = ctypes.c_bool
_BNWriteBE64.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWriteBE64(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWriteBE64(stream, val)
# -------------------------------------------------------
# _BNWriteData
_BNWriteData = core.BNWriteData
_BNWriteData.restype = ctypes.c_bool
_BNWriteData.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_void_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWriteData(
stream: ctypes.POINTER(BNBinaryWriter),
src: Optional[ctypes.c_void_p],
len: int
) -> bool:
return _BNWriteData(stream, src, len)
# -------------------------------------------------------
# _BNWriteDataForDownloadInstance
_BNWriteDataForDownloadInstance = core.BNWriteDataForDownloadInstance
_BNWriteDataForDownloadInstance.restype = ctypes.c_ulonglong
_BNWriteDataForDownloadInstance.argtypes = [
ctypes.POINTER(BNDownloadInstance),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWriteDataForDownloadInstance(
instance: ctypes.POINTER(BNDownloadInstance),
data: ctypes.POINTER(ctypes.c_ubyte),
len: int
) -> int:
return _BNWriteDataForDownloadInstance(instance, data, len)
# -------------------------------------------------------
# _BNWriteDatabaseAnalysisCache
_BNWriteDatabaseAnalysisCache = core.BNWriteDatabaseAnalysisCache
_BNWriteDatabaseAnalysisCache.restype = ctypes.c_bool
_BNWriteDatabaseAnalysisCache.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.POINTER(BNKeyValueStore),
]
# noinspection PyPep8Naming
def BNWriteDatabaseAnalysisCache(
database: ctypes.POINTER(BNDatabase),
val: ctypes.POINTER(BNKeyValueStore)
) -> bool:
return _BNWriteDatabaseAnalysisCache(database, val)
# -------------------------------------------------------
# _BNWriteDatabaseGlobal
_BNWriteDatabaseGlobal = core.BNWriteDatabaseGlobal
_BNWriteDatabaseGlobal.restype = ctypes.c_bool
_BNWriteDatabaseGlobal.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_char_p,
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWriteDatabaseGlobal(
database: ctypes.POINTER(BNDatabase),
key: Optional[str],
val: Optional[str]
) -> bool:
return _BNWriteDatabaseGlobal(database, cstr(key), cstr(val))
# -------------------------------------------------------
# _BNWriteDatabaseGlobalData
_BNWriteDatabaseGlobalData = core.BNWriteDatabaseGlobalData
_BNWriteDatabaseGlobalData.restype = ctypes.c_bool
_BNWriteDatabaseGlobalData.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.c_char_p,
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNWriteDatabaseGlobalData(
database: ctypes.POINTER(BNDatabase),
key: Optional[str],
val: ctypes.POINTER(BNDataBuffer)
) -> bool:
return _BNWriteDatabaseGlobalData(database, cstr(key), val)
# -------------------------------------------------------
# _BNWriteDatabaseSnapshotData
_BNWriteDatabaseSnapshotData = core.BNWriteDatabaseSnapshotData
_BNWriteDatabaseSnapshotData.restype = ctypes.c_longlong
_BNWriteDatabaseSnapshotData.argtypes = [
ctypes.POINTER(BNDatabase),
ctypes.POINTER(ctypes.c_longlong),
ctypes.c_ulonglong,
ctypes.POINTER(BNBinaryView),
ctypes.c_char_p,
ctypes.POINTER(BNKeyValueStore),
ctypes.c_bool,
ctypes.c_void_p,
ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong),
]
# noinspection PyPep8Naming
def BNWriteDatabaseSnapshotData(
database: ctypes.POINTER(BNDatabase),
parents: ctypes.POINTER(ctypes.c_longlong),
parentCount: int,
file: ctypes.POINTER(BNBinaryView),
name: Optional[str],
data: ctypes.POINTER(BNKeyValueStore),
autoSave: bool,
ctxt: Optional[ctypes.c_void_p],
progress: ctypes.CFUNCTYPE(ctypes.c_bool, ctypes.c_void_p, ctypes.c_ulonglong, ctypes.c_ulonglong)
) -> int:
return _BNWriteDatabaseSnapshotData(database, parents, parentCount, file, cstr(name), data, autoSave, ctxt, progress)
# -------------------------------------------------------
# _BNWriteLE16
_BNWriteLE16 = core.BNWriteLE16
_BNWriteLE16.restype = ctypes.c_bool
_BNWriteLE16.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_ushort,
]
# noinspection PyPep8Naming
def BNWriteLE16(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWriteLE16(stream, val)
# -------------------------------------------------------
# _BNWriteLE32
_BNWriteLE32 = core.BNWriteLE32
_BNWriteLE32.restype = ctypes.c_bool
_BNWriteLE32.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_uint,
]
# noinspection PyPep8Naming
def BNWriteLE32(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWriteLE32(stream, val)
# -------------------------------------------------------
# _BNWriteLE64
_BNWriteLE64 = core.BNWriteLE64
_BNWriteLE64.restype = ctypes.c_bool
_BNWriteLE64.argtypes = [
ctypes.POINTER(BNBinaryWriter),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWriteLE64(
stream: ctypes.POINTER(BNBinaryWriter),
val: int
) -> bool:
return _BNWriteLE64(stream, val)
# -------------------------------------------------------
# _BNWriteTypeLibraryToFile
_BNWriteTypeLibraryToFile = core.BNWriteTypeLibraryToFile
_BNWriteTypeLibraryToFile.restype = None
_BNWriteTypeLibraryToFile.argtypes = [
ctypes.POINTER(BNTypeLibrary),
ctypes.c_char_p,
]
# noinspection PyPep8Naming
def BNWriteTypeLibraryToFile(
lib: ctypes.POINTER(BNTypeLibrary),
path: Optional[str]
) -> None:
return _BNWriteTypeLibraryToFile(lib, cstr(path))
# -------------------------------------------------------
# _BNWriteViewBuffer
_BNWriteViewBuffer = core.BNWriteViewBuffer
_BNWriteViewBuffer.restype = ctypes.c_ulonglong
_BNWriteViewBuffer.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNWriteViewBuffer(
view: ctypes.POINTER(BNBinaryView),
offset: int,
data: ctypes.POINTER(BNDataBuffer)
) -> int:
return _BNWriteViewBuffer(view, offset, data)
# -------------------------------------------------------
# _BNWriteViewData
_BNWriteViewData = core.BNWriteViewData
_BNWriteViewData.restype = ctypes.c_ulonglong
_BNWriteViewData.argtypes = [
ctypes.POINTER(BNBinaryView),
ctypes.c_ulonglong,
ctypes.c_void_p,
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWriteViewData(
view: ctypes.POINTER(BNBinaryView),
offset: int,
data: Optional[ctypes.c_void_p],
len: int
) -> int:
return _BNWriteViewData(view, offset, data, len)
# -------------------------------------------------------
# _BNWriteWebsocketClientData
_BNWriteWebsocketClientData = core.BNWriteWebsocketClientData
_BNWriteWebsocketClientData.restype = ctypes.c_ulonglong
_BNWriteWebsocketClientData.argtypes = [
ctypes.POINTER(BNWebsocketClient),
ctypes.POINTER(ctypes.c_ubyte),
ctypes.c_ulonglong,
]
# noinspection PyPep8Naming
def BNWriteWebsocketClientData(
client: ctypes.POINTER(BNWebsocketClient),
data: ctypes.POINTER(ctypes.c_ubyte),
len: int
) -> int:
return _BNWriteWebsocketClientData(client, data, len)
# -------------------------------------------------------
# _BNZlibCompress
_BNZlibCompress = core.BNZlibCompress
_BNZlibCompress.restype = ctypes.POINTER(BNDataBuffer)
_BNZlibCompress.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNZlibCompress(
buf: ctypes.POINTER(BNDataBuffer)
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNZlibCompress(buf)
if not result:
return None
return result
# -------------------------------------------------------
# _BNZlibDecompress
_BNZlibDecompress = core.BNZlibDecompress
_BNZlibDecompress.restype = ctypes.POINTER(BNDataBuffer)
_BNZlibDecompress.argtypes = [
ctypes.POINTER(BNDataBuffer),
]
# noinspection PyPep8Naming
def BNZlibDecompress(
buf: ctypes.POINTER(BNDataBuffer)
) -> Optional[ctypes.POINTER(BNDataBuffer)]:
result = _BNZlibDecompress(buf)
if not result:
return None
return result
max_confidence = 255
# Helper functions
def handle_of_type(value, handle_type):
if isinstance(value, ctypes.POINTER(handle_type)) or isinstance(value, ctypes.c_void_p):
return ctypes.cast(value, ctypes.POINTER(handle_type))
raise ValueError('expected pointer to %s' % str(handle_type))
# Set path for core plugins
BNSetBundledPluginDirectory(os.path.join(_base_path, "plugins"))