#![allow(non_snake_case)]
use core::mem::MaybeUninit;
use core::ptr;
use super::*;
use super::bindings::*;
use crate::cpp::*;
impl AddTreeState {
pub fn apply(&mut self) -> bool {
unsafe {
AddTreeState_apply(self)
}
}
pub fn init_alternate_form(&mut self) -> bool {
unsafe {
AddTreeState_initAlternateForm(self)
}
}
}
impl AdditiveEdge {
pub fn get_multiplier(&self) -> Option<&mut PcodeOp> {
unsafe {
AdditiveEdge_getMultiplier(self).as_mut()
}
}
pub fn get_op(&self) -> Option<&mut PcodeOp> {
unsafe {
AdditiveEdge_getOp(self).as_mut()
}
}
pub fn get_slot(&self) -> i32 {
unsafe {
AdditiveEdge_getSlot(self)
}
}
pub fn get_varnode(&self) -> Option<&mut Varnode> {
unsafe {
AdditiveEdge_getVarnode(self).as_mut()
}
}
}
impl AddrSpace {
pub fn does_deadcode(&self) -> bool {
unsafe {
AddrSpace_doesDeadcode(self)
}
}
pub fn get_addr_size(&self) -> u32 {
unsafe {
AddrSpace_getAddrSize(self)
}
}
pub fn get_contain(&self) -> Option<&mut AddrSpace> {
unsafe {
AddrSpace_getContain(self).as_mut()
}
}
pub fn get_highest(&self) -> u64 {
unsafe {
AddrSpace_getHighest(self)
}
}
pub fn get_index(&self) -> i32 {
unsafe {
AddrSpace_getIndex(self)
}
}
pub fn get_type(&self) -> Spacetype {
unsafe {
AddrSpace_getType(self)
}
}
pub fn get_word_size(&self) -> u32 {
unsafe {
AddrSpace_getWordSize(self)
}
}
pub fn is_big_endian(&self) -> bool {
unsafe {
AddrSpace_isBigEndian(self)
}
}
pub fn is_truncated(&self) -> bool {
unsafe {
AddrSpace_isTruncated(self)
}
}
}
impl AddrSpaceManager {
pub fn find_join(&self, offset: u64) -> Option<&mut JoinRecord> {
unsafe {
AddrSpaceManager_findJoin(self, offset).as_mut()
}
}
pub fn get_constant(&self, val: u64) -> Address {
unsafe {
let mut retval = MaybeUninit::uninit();
AddrSpaceManager_getConstant(self, val, retval.as_mut_ptr());
retval.assume_init()
}
}
pub fn get_default_code_space(&self) -> Option<&mut AddrSpace> {
unsafe {
AddrSpaceManager_getDefaultCodeSpace(self).as_mut()
}
}
pub fn get_default_data_space(&self) -> Option<&mut AddrSpace> {
unsafe {
AddrSpaceManager_getDefaultDataSpace(self).as_mut()
}
}
}
impl Address {
pub fn is_big_endian(&self) -> bool {
unsafe {
Address_isBigEndian(self)
}
}
pub fn is_join(&self) -> bool {
unsafe {
Address_isJoin(self)
}
}
pub fn overlap(&self, skip: i32, op: &Address, size: i32) -> i32 {
unsafe {
Address_overlap(self, skip, op, size)
}
}
pub fn renormalize(&mut self, size: i32) {
unsafe {
Address_renormalize(self, size)
}
}
}
impl Architecture {
pub fn get_space_by_spacebase(&self, loc: &Address, size: i32) -> Option<&mut AddrSpace> {
unsafe {
Architecture_getSpaceBySpacebase(self, loc, size).as_mut()
}
}
}
impl BlockBasic {
pub fn earliest_use(&mut self, vn: &mut Varnode) -> Option<&mut PcodeOp> {
unsafe {
BlockBasic_earliestUse(self, vn).as_mut()
}
}
pub fn get_start(&self) -> Address {
unsafe {
let mut retval = MaybeUninit::uninit();
BlockBasic_getStart(self, retval.as_mut_ptr());
retval.assume_init()
}
}
pub fn last_op(&self) -> Option<&mut PcodeOp> {
unsafe {
BlockBasic_lastOp(self).as_mut()
}
}
}
impl BlockGraph {
pub fn clear(&mut self) {
unsafe {
BlockGraph_clear(self)
}
}
pub fn get_block(&self, i: i32) -> Option<&mut FlowBlock> {
unsafe {
BlockGraph_getBlock(self, i).as_mut()
}
}
}
impl CPoolRecord {
pub fn get_tag(&self) -> u32 {
unsafe {
CPoolRecord_getTag(self)
}
}
pub fn get_type(&self) -> Option<&mut Datatype> {
unsafe {
CPoolRecord_getType(self).as_mut()
}
}
pub fn get_value(&self) -> u64 {
unsafe {
CPoolRecord_getValue(self)
}
}
}
impl CircleRange {
pub fn circle_union(&mut self, op2: &CircleRange) -> i32 {
unsafe {
CircleRange_circleUnion(self, op2)
}
}
pub fn intersect(&mut self, op2: &CircleRange) -> i32 {
unsafe {
CircleRange_intersect(self, op2)
}
}
pub fn translate_2_op(&self, opc: &mut OpCode, c: &mut u64, cslot: &mut i32) -> i32 {
unsafe {
CircleRange_translate2Op(self, opc, c, cslot)
}
}
}
impl CloneBlockOps {
pub fn clone_expression(&mut self, ops: &mut StdVector<&mut PcodeOp>, followOp: &mut PcodeOp) -> Option<&mut Varnode> {
unsafe {
CloneBlockOps_cloneExpression(self, ptr::from_mut(ops).cast(), followOp).as_mut()
}
}
}
impl ConstantPool {
pub fn get_record(&self, refs: &StdVector<u64>) -> Option<&CPoolRecord> {
unsafe {
ConstantPool_getRecord(self, ptr::from_ref(refs).cast()).as_ref()
}
}
}
impl Datatype {
pub fn get_align_size(&self) -> i32 {
unsafe {
Datatype_getAlignSize(self)
}
}
pub fn get_metatype(&self) -> TypeMetatype {
unsafe {
Datatype_getMetatype(self)
}
}
pub fn get_size(&self) -> i32 {
unsafe {
Datatype_getSize(self)
}
}
pub fn get_sub_type(&self, off: i64, newoff: &mut i64) -> Option<&mut Datatype> {
unsafe {
Datatype_getSubType(self, off, newoff).as_mut()
}
}
pub fn is_char_print(&self) -> bool {
unsafe {
Datatype_isCharPrint(self)
}
}
pub fn is_enum_type(&self) -> bool {
unsafe {
Datatype_isEnumType(self)
}
}
pub fn is_formal_pointer_rel(&self) -> bool {
unsafe {
Datatype_isFormalPointerRel(self)
}
}
pub fn is_piece_structured(&self) -> bool {
unsafe {
Datatype_isPieceStructured(self)
}
}
pub fn is_ptrsub_matching(&self, off: i64, extra: i64, multiplier: i64) -> bool {
unsafe {
Datatype_isPtrsubMatching(self, off, extra, multiplier)
}
}
pub fn needs_resolution(&self) -> bool {
unsafe {
Datatype_needsResolution(self)
}
}
pub fn resolve_in_flow(&mut self, op: &mut PcodeOp, slot: i32) -> Option<&mut Datatype> {
unsafe {
Datatype_resolveInFlow(self, op, slot).as_mut()
}
}
}
impl FlowBlock {
pub fn get_false_out(&self) -> Option<&mut FlowBlock> {
unsafe {
FlowBlock_getFalseOut(self).as_mut()
}
}
pub fn get_in(&mut self, i: i32) -> Option<&mut FlowBlock> {
unsafe {
FlowBlock_getIn(self, i).as_mut()
}
}
pub fn get_index(&self) -> i32 {
unsafe {
FlowBlock_getIndex(self)
}
}
pub fn get_out(&mut self, i: i32) -> Option<&mut FlowBlock> {
unsafe {
FlowBlock_getOut(self, i).as_mut()
}
}
pub fn get_true_out(&self) -> Option<&mut FlowBlock> {
unsafe {
FlowBlock_getTrueOut(self).as_mut()
}
}
pub fn has_loop_in(&self) -> bool {
unsafe {
FlowBlock_hasLoopIn(self)
}
}
pub fn last_op(&self) -> Option<&mut PcodeOp> {
unsafe {
FlowBlock_lastOp(self).as_mut()
}
}
pub fn size_in(&self) -> i32 {
unsafe {
FlowBlock_sizeIn(self)
}
}
pub fn size_out(&self) -> i32 {
unsafe {
FlowBlock_sizeOut(self)
}
}
}
impl FuncCallSpecs {
pub fn get_name(&self) -> Option<&StdString> {
unsafe {
FuncCallSpecs_getName(self).as_ref()
}
}
pub fn is_input_active(&self) -> bool {
unsafe {
FuncCallSpecs_isInputActive(self)
}
}
pub fn is_output_active(&self) -> bool {
unsafe {
FuncCallSpecs_isOutputActive(self)
}
}
pub fn resolve_spacebase_relative(&mut self, data: &mut Funcdata, phvn: &mut Varnode) {
unsafe {
FuncCallSpecs_resolveSpacebaseRelative(self, data, phvn)
}
}
pub fn set_input_bytes_consumed(&self, slot: i32, val: i32) -> bool {
unsafe {
FuncCallSpecs_setInputBytesConsumed(self, slot, val)
}
}
}
impl FuncProto {
pub fn is_input_locked(&self) -> bool {
unsafe {
FuncProto_isInputLocked(self)
}
}
pub fn is_output_locked(&self) -> bool {
unsafe {
FuncProto_isOutputLocked(self)
}
}
pub fn set_return_bytes_consumed(&mut self, val: i32) -> bool {
unsafe {
FuncProto_setReturnBytesConsumed(self, val)
}
}
}
impl Funcdata {
pub fn cse_eliminate_list(&mut self, list: &mut StdVector<CSEHashPair>, outlist: &mut StdVector<&mut Varnode>) {
unsafe {
Funcdata_cseEliminateList(self, ptr::from_mut(list).cast(), ptr::from_mut(outlist).cast())
}
}
pub fn dead_removal_allowed_seen(&mut self, spc: &mut AddrSpace) -> bool {
unsafe {
Funcdata_deadRemovalAllowedSeen(self, spc)
}
}
pub fn delete_varnode(&mut self, vn: &mut Varnode) {
unsafe {
Funcdata_deleteVarnode(self, vn)
}
}
pub fn distribute_int_mult_add(&mut self, op: &mut PcodeOp) -> bool {
unsafe {
Funcdata_distributeIntMultAdd(self, op)
}
}
pub fn find_jump_table(&self, op: &PcodeOp) -> Option<&mut JumpTable> {
unsafe {
Funcdata_findJumpTable(self, op).as_mut()
}
}
pub fn get_arch(&self) -> Option<&mut Architecture> {
unsafe {
Funcdata_getArch(self).as_mut()
}
}
pub fn get_basic_blocks(&self) -> Option<&BlockGraph> {
unsafe {
Funcdata_getBasicBlocks(self).as_ref()
}
}
pub fn get_call_specs(&self, op: &PcodeOp) -> Option<&mut FuncCallSpecs> {
unsafe {
Funcdata_getCallSpecs(self, op).as_mut()
}
}
pub fn get_func_proto(&mut self) -> Option<&mut FuncProto> {
unsafe {
Funcdata_getFuncProto(self).as_mut()
}
}
pub fn get_merge(&mut self) -> Option<&mut Merge> {
unsafe {
Funcdata_getMerge(self).as_mut()
}
}
pub fn get_scope_local(&mut self) -> Option<&mut ScopeLocal> {
unsafe {
Funcdata_getScopeLocal(self).as_mut()
}
}
pub fn get_store_guard(&self, op: &mut PcodeOp) -> Option<&LoadGuard> {
unsafe {
Funcdata_getStoreGuard(self, op).as_ref()
}
}
pub fn get_structure(&mut self) -> Option<&mut BlockGraph> {
unsafe {
Funcdata_getStructure(self).as_mut()
}
}
pub fn has_type_recovery_started(&self) -> bool {
unsafe {
Funcdata_hasTypeRecoveryStarted(self)
}
}
pub fn inherit_resolution(&mut self, parent: &mut Datatype, op: &PcodeOp, slot: i32, oldOp: &mut PcodeOp, oldSlot: i32) -> i32 {
unsafe {
Funcdata_inheritResolution(self, parent, op, slot, oldOp, oldSlot)
}
}
pub fn is_type_recovery_on(&self) -> bool {
unsafe {
Funcdata_isTypeRecoveryOn(self)
}
}
pub fn new_code_ref(&mut self, m: &Address) -> Option<&mut Varnode> {
unsafe {
Funcdata_newCodeRef(self, m).as_mut()
}
}
pub fn new_constant(&mut self, s: i32, constant_val: u64) -> Option<&mut Varnode> {
unsafe {
Funcdata_newConstant(self, s, constant_val).as_mut()
}
}
pub fn new_extended_constant(&mut self, s: i32, val: &mut u64, op: &mut PcodeOp) -> Option<&mut Varnode> {
unsafe {
Funcdata_newExtendedConstant(self, s, val, op).as_mut()
}
}
pub fn new_indirect_creation(&mut self, indeffect: &mut PcodeOp, addr: &Address, sz: i32, possibleout: bool) -> Option<&mut PcodeOp> {
unsafe {
Funcdata_newIndirectCreation(self, indeffect, addr, sz, possibleout).as_mut()
}
}
pub fn new_op(&mut self, inputs: i32, pc: &Address) -> Option<&mut PcodeOp> {
unsafe {
Funcdata_newOp(self, inputs, pc).as_mut()
}
}
pub fn new_op_before(&mut self, follow: &mut PcodeOp, opc: OpCode, in1: &mut Varnode, in2: &mut Varnode, in3: &mut Varnode) -> Option<&mut PcodeOp> {
unsafe {
Funcdata_newOpBefore(self, follow, opc, in1, in2, in3).as_mut()
}
}
pub fn new_unique(&mut self, s: i32, ct: &mut Datatype) -> Option<&mut Varnode> {
unsafe {
Funcdata_newUnique(self, s, ct).as_mut()
}
}
pub fn new_unique_out(&mut self, s: i32, op: &mut PcodeOp) -> Option<&mut Varnode> {
unsafe {
Funcdata_newUniqueOut(self, s, op).as_mut()
}
}
pub fn new_varnode(&mut self, s: i32, m: &Address, ct: &mut Datatype) -> Option<&mut Varnode> {
unsafe {
Funcdata_newVarnode(self, s, m, ct).as_mut()
}
}
pub fn new_varnode1(&mut self, s: i32, base: &mut AddrSpace, off: u64) -> Option<&mut Varnode> {
unsafe {
Funcdata_newVarnode1(self, s, base, off).as_mut()
}
}
pub fn new_varnode_iop(&mut self, op: &mut PcodeOp) -> Option<&mut Varnode> {
unsafe {
Funcdata_newVarnodeIop(self, op).as_mut()
}
}
pub fn new_varnode_out(&mut self, s: i32, m: &Address, op: &mut PcodeOp) -> Option<&mut Varnode> {
unsafe {
Funcdata_newVarnodeOut(self, s, m, op).as_mut()
}
}
pub fn op_bool_negate(&mut self, vn: &mut Varnode, op: &mut PcodeOp, insertafter: bool) -> Option<&mut Varnode> {
unsafe {
Funcdata_opBoolNegate(self, vn, op, insertafter).as_mut()
}
}
pub fn op_destroy(&mut self, op: &mut PcodeOp) {
unsafe {
Funcdata_opDestroy(self, op)
}
}
pub fn op_flip_condition(&mut self, op: &mut PcodeOp) {
unsafe {
Funcdata_opFlipCondition(self, op)
}
}
pub fn op_insert_after(&mut self, op: &mut PcodeOp, prev: &mut PcodeOp) {
unsafe {
Funcdata_opInsertAfter(self, op, prev)
}
}
pub fn op_insert_before(&mut self, op: &mut PcodeOp, follow: &mut PcodeOp) {
unsafe {
Funcdata_opInsertBefore(self, op, follow)
}
}
pub fn op_insert_begin(&mut self, op: &mut PcodeOp, bl: &mut BlockBasic) {
unsafe {
Funcdata_opInsertBegin(self, op, bl)
}
}
pub fn op_insert_input(&mut self, op: &mut PcodeOp, vn: &mut Varnode, slot: i32) {
unsafe {
Funcdata_opInsertInput(self, op, vn, slot)
}
}
pub fn op_mark_calculated_bool(&mut self, op: &mut PcodeOp) {
unsafe {
Funcdata_opMarkCalculatedBool(self, op)
}
}
pub fn op_mark_cpool_transformed(&mut self, op: &mut PcodeOp) {
unsafe {
Funcdata_opMarkCpoolTransformed(self, op)
}
}
pub fn op_mark_no_collapse(&mut self, op: &mut PcodeOp) {
unsafe {
Funcdata_opMarkNoCollapse(self, op)
}
}
pub fn op_mark_special_print(&mut self, op: &mut PcodeOp) {
unsafe {
Funcdata_opMarkSpecialPrint(self, op)
}
}
pub fn op_remove_input(&mut self, op: &mut PcodeOp, slot: i32) {
unsafe {
Funcdata_opRemoveInput(self, op, slot)
}
}
pub fn op_set_all_input(&mut self, op: &mut PcodeOp, vvec: &StdVector<&mut Varnode>) {
unsafe {
Funcdata_opSetAllInput(self, op, ptr::from_ref(vvec).cast())
}
}
pub fn op_set_input(&mut self, op: &mut PcodeOp, vn: &mut Varnode, slot: i32) {
unsafe {
Funcdata_opSetInput(self, op, vn, slot)
}
}
pub fn op_set_opcode(&mut self, op: &mut PcodeOp, opc: OpCode) {
unsafe {
Funcdata_opSetOpcode(self, op, opc)
}
}
pub fn op_set_output(&mut self, op: &mut PcodeOp, vn: &mut Varnode) {
unsafe {
Funcdata_opSetOutput(self, op, vn)
}
}
pub fn op_swap_input(&mut self, op: &mut PcodeOp, slot1: i32, slot2: i32) {
unsafe {
Funcdata_opSwapInput(self, op, slot1, slot2)
}
}
pub fn op_undo_ptradd(&mut self, op: &mut PcodeOp, finalize: bool) {
unsafe {
Funcdata_opUndoPtradd(self, op, finalize)
}
}
pub fn op_uninsert(&mut self, op: &mut PcodeOp) {
unsafe {
Funcdata_opUninsert(self, op)
}
}
pub fn op_unlink(&mut self, op: &mut PcodeOp) {
unsafe {
Funcdata_opUnlink(self, op)
}
}
pub fn op_unset_input(&mut self, op: &mut PcodeOp, slot: i32) {
unsafe {
Funcdata_opUnsetInput(self, op, slot)
}
}
pub fn op_unset_output(&mut self, op: &mut PcodeOp) {
unsafe {
Funcdata_opUnsetOutput(self, op)
}
}
pub fn remove_jump_table(&mut self, jt: &mut JumpTable) {
unsafe {
Funcdata_removeJumpTable(self, jt)
}
}
pub fn replace_lessequal(&mut self, op: &mut PcodeOp) -> bool {
unsafe {
Funcdata_replaceLessequal(self, op)
}
}
pub fn total_replace(&mut self, vn: &mut Varnode, newvn: &mut Varnode) {
unsafe {
Funcdata_totalReplace(self, vn, newvn)
}
}
pub fn warning(&self, txt: &StdString, ad: &Address) {
unsafe {
Funcdata_warning(self, txt, ad)
}
}
pub fn warning_header(&self, txt: &StdString) {
unsafe {
Funcdata_warningHeader(self, txt)
}
}
}
impl JoinRecord {
pub fn get_piece(&self, i: i32) -> Option<&VarnodeData> {
unsafe {
JoinRecord_getPiece(self, i).as_ref()
}
}
pub fn num_pieces(&self) -> i32 {
unsafe {
JoinRecord_numPieces(self)
}
}
}
impl JumpTable {
pub fn get_address_by_index(&self, i: i32) -> Address {
unsafe {
let mut retval = MaybeUninit::uninit();
JumpTable_getAddressByIndex(self, i, retval.as_mut_ptr());
retval.assume_init()
}
}
pub fn is_labelled(&self) -> bool {
unsafe {
JumpTable_isLabelled(self)
}
}
pub fn num_entries(&self) -> i32 {
unsafe {
JumpTable_numEntries(self)
}
}
}
impl LoadGuard {
pub fn is_guarded(&self, addr: &Address) -> bool {
unsafe {
LoadGuard_isGuarded(self, addr)
}
}
}
impl Merge {
pub fn register_proto_partial_root(&mut self, vn: &mut Varnode) {
unsafe {
Merge_registerProtoPartialRoot(self, vn)
}
}
}
impl PcodeOp {
pub fn clear_mark(&self) {
unsafe {
PcodeOp_clearMark(self)
}
}
pub fn clear_stop_type_propagation(&mut self) {
unsafe {
PcodeOp_clearStopTypePropagation(self)
}
}
pub fn code(&self) -> OpCode {
unsafe {
PcodeOp_code(self)
}
}
pub fn collapse(&self, markedInput: &mut bool) -> u64 {
unsafe {
PcodeOp_collapse(self, markedInput)
}
}
pub fn collapse_constant_symbol(&self, newConst: &mut Varnode) {
unsafe {
PcodeOp_collapseConstantSymbol(self, newConst)
}
}
pub fn does_special_printing(&self) -> bool {
unsafe {
PcodeOp_doesSpecialPrinting(self)
}
}
pub fn get_addr(&self) -> Option<&Address> {
unsafe {
PcodeOp_getAddr(self).as_ref()
}
}
pub fn get_cse_hash(&self) -> u32 {
unsafe {
PcodeOp_getCseHash(self)
}
}
pub fn get_eval_type(&self) -> u32 {
unsafe {
PcodeOp_getEvalType(self)
}
}
pub fn get_in(&mut self, slot: i32) -> Option<&mut Varnode> {
unsafe {
PcodeOp_getIn(self, slot).as_mut()
}
}
pub fn get_opcode(&self) -> Option<&mut TypeOp> {
unsafe {
PcodeOp_getOpcode(self).as_mut()
}
}
pub fn get_out(&mut self) -> Option<&mut Varnode> {
unsafe {
PcodeOp_getOut(self).as_mut()
}
}
pub fn get_parent(&mut self) -> Option<&mut BlockBasic> {
unsafe {
PcodeOp_getParent(self).as_mut()
}
}
pub fn get_seq_num(&self) -> Option<&SeqNum> {
unsafe {
PcodeOp_getSeqNum(self).as_ref()
}
}
pub fn get_slot(&self, vn: &Varnode) -> i32 {
unsafe {
PcodeOp_getSlot(self, vn)
}
}
pub fn is_bool_output(&self) -> bool {
unsafe {
PcodeOp_isBoolOutput(self)
}
}
pub fn is_boolean_flip(&self) -> bool {
unsafe {
PcodeOp_isBooleanFlip(self)
}
}
pub fn is_call(&self) -> bool {
unsafe {
PcodeOp_isCall(self)
}
}
pub fn is_collapsible(&self) -> bool {
unsafe {
PcodeOp_isCollapsible(self)
}
}
pub fn is_cpool_transformed(&self) -> bool {
unsafe {
PcodeOp_isCpoolTransformed(self)
}
}
pub fn is_cse_match(&self, op: &PcodeOp) -> bool {
unsafe {
PcodeOp_isCseMatch(self, op)
}
}
pub fn is_dead(&self) -> bool {
unsafe {
PcodeOp_isDead(self)
}
}
pub fn is_indirect_creation(&self) -> bool {
unsafe {
PcodeOp_isIndirectCreation(self)
}
}
pub fn is_indirect_source(&self) -> bool {
unsafe {
PcodeOp_isIndirectSource(self)
}
}
pub fn is_mark(&self) -> bool {
unsafe {
PcodeOp_isMark(self)
}
}
pub fn is_marker(&self) -> bool {
unsafe {
PcodeOp_isMarker(self)
}
}
pub fn is_partial_root(&self) -> bool {
unsafe {
PcodeOp_isPartialRoot(self)
}
}
pub fn is_ptr_flow(&self) -> bool {
unsafe {
PcodeOp_isPtrFlow(self)
}
}
pub fn is_return_copy(&self) -> bool {
unsafe {
PcodeOp_isReturnCopy(self)
}
}
pub fn is_store_unmapped(&self) -> bool {
unsafe {
PcodeOp_isStoreUnmapped(self)
}
}
pub fn no_indirect_collapse(&self) -> bool {
unsafe {
PcodeOp_noIndirectCollapse(self)
}
}
pub fn num_input(&self) -> i32 {
unsafe {
PcodeOp_numInput(self)
}
}
pub fn set_mark(&self) {
unsafe {
PcodeOp_setMark(self)
}
}
pub fn set_partial_root(&mut self) {
unsafe {
PcodeOp_setPartialRoot(self)
}
}
pub fn set_ptr_flow(&mut self) {
unsafe {
PcodeOp_setPtrFlow(self)
}
}
pub fn set_stop_type_propagation(&mut self) {
unsafe {
PcodeOp_setStopTypePropagation(self)
}
}
pub fn uses_spacebase_ptr(&self) -> bool {
unsafe {
PcodeOp_usesSpacebasePtr(self)
}
}
}
impl PieceNode {
pub fn get_op(&self) -> Option<&mut PcodeOp> {
unsafe {
PieceNode_getOp(self).as_mut()
}
}
pub fn get_slot(&self) -> i32 {
unsafe {
PieceNode_getSlot(self)
}
}
pub fn get_type_offset(&self) -> i32 {
unsafe {
PieceNode_getTypeOffset(self)
}
}
pub fn get_varnode(&self) -> Option<&mut Varnode> {
unsafe {
PieceNode_getVarnode(self).as_mut()
}
}
pub fn is_leaf(&self) -> bool {
unsafe {
PieceNode_isLeaf(self)
}
}
}
impl Scope {
pub fn is_read_only(&self, addr: &Address, size: i32, usepoint: &Address) -> bool {
unsafe {
Scope_isReadOnly(self, addr, size, usepoint)
}
}
}
impl ScopeLocal {
pub fn mark_not_mapped(&mut self, spc: &mut AddrSpace, first: u64, sz: i32, param: bool) {
unsafe {
ScopeLocal_markNotMapped(self, spc, first, sz, param)
}
}
}
impl SegmentOp {
pub fn execute(&self, input: &StdVector<u64>) -> u64 {
unsafe {
SegmentOp_execute(self, ptr::from_ref(input).cast())
}
}
pub fn has_far_pointer_support(&self) -> bool {
unsafe {
SegmentOp_hasFarPointerSupport(self)
}
}
}
impl SeqNum {
pub fn get_order(&self) -> u32 {
unsafe {
SeqNum_getOrder(self)
}
}
}
impl StringManager {
pub fn is_string(&mut self, addr: &Address, charType: &mut Datatype) -> bool {
unsafe {
StringManager_isString(self, addr, charType)
}
}
}
impl Symbol {
pub fn is_name_locked(&self) -> bool {
unsafe {
Symbol_isNameLocked(self)
}
}
}
impl SymbolEntry {
pub fn get_addr(&self) -> Option<&Address> {
unsafe {
SymbolEntry_getAddr(self).as_ref()
}
}
pub fn get_offset(&self) -> i32 {
unsafe {
SymbolEntry_getOffset(self)
}
}
pub fn get_symbol(&self) -> Option<&mut Symbol> {
unsafe {
SymbolEntry_getSymbol(self).as_mut()
}
}
}
impl TermOrder {
pub fn collect(&mut self) {
unsafe {
TermOrder_collect(self)
}
}
pub fn get_sort(&mut self) -> Option<&StdVectorPtrAdditiveEdge> {
unsafe {
TermOrder_getSort(self).as_ref()
}
}
pub fn sort_terms(&mut self) {
unsafe {
TermOrder_sortTerms(self)
}
}
}
impl TypeArray {
pub fn num_elements(&self) -> i32 {
unsafe {
TypeArray_numElements(self)
}
}
}
impl TypeEnum {
pub fn has_named_value(&self, val: u64) -> bool {
unsafe {
TypeEnum_hasNamedValue(self, val)
}
}
}
impl TypeFactory {
pub fn get_base(&mut self, s: i32, m: TypeMetatype) -> Option<&mut Datatype> {
unsafe {
TypeFactory_getBase(self, s, m).as_mut()
}
}
pub fn get_exact_piece(&mut self, ct: &mut Datatype, offset: i32, size: i32) -> Option<&mut Datatype> {
unsafe {
TypeFactory_getExactPiece(self, ct, offset, size).as_mut()
}
}
}
impl TypeOp {
pub fn evaluate_binary(&self, sizeout: i32, sizein: i32, in1: u64, in2: u64) -> u64 {
unsafe {
TypeOp_evaluateBinary(self, sizeout, sizein, in1, in2)
}
}
pub fn is_floating_point_op(&self) -> bool {
unsafe {
TypeOp_isFloatingPointOp(self)
}
}
}
impl TypePointer {
pub fn get_ptr_to(&self) -> Option<&mut Datatype> {
unsafe {
TypePointer_getPtrTo(self).as_mut()
}
}
pub fn get_word_size(&self) -> u32 {
unsafe {
TypePointer_getWordSize(self)
}
}
}
impl TypePointerRel {
pub fn evaluate_thru_parent(&self, addrOff: u64) -> bool {
unsafe {
TypePointerRel_evaluateThruParent(self, addrOff)
}
}
pub fn get_byte_offset(&self) -> i32 {
unsafe {
TypePointerRel_getByteOffset(self)
}
}
pub fn get_parent(&self) -> Option<&mut Datatype> {
unsafe {
TypePointerRel_getParent(self).as_mut()
}
}
}
impl TypeSpacebase {
pub fn get_address(&self, off: u64, sz: i32, point: &Address) -> Address {
unsafe {
let mut retval = MaybeUninit::uninit();
TypeSpacebase_getAddress(self, off, sz, point, retval.as_mut_ptr());
retval.assume_init()
}
}
pub fn get_map(&self) -> Option<&mut Scope> {
unsafe {
TypeSpacebase_getMap(self).as_mut()
}
}
}
impl UserOpManage {
pub fn get_segment_op(&self, i: i32) -> Option<&mut SegmentOp> {
unsafe {
UserOpManage_getSegmentOp(self, i).as_mut()
}
}
}
impl Varnode {
pub fn begin_descend(&self) -> StdConstIterPtrPcodeOp {
unsafe {
let mut retval = MaybeUninit::uninit();
Varnode_beginDescend(self, retval.as_mut_ptr());
retval.assume_init()
}
}
pub fn characterize_overlap(&self, op: &Varnode) -> i32 {
unsafe {
Varnode_characterizeOverlap(self, op)
}
}
pub fn clear_mark(&self) {
unsafe {
Varnode_clearMark(self)
}
}
pub fn clear_spacebase_placeholder(&mut self) {
unsafe {
Varnode_clearSpacebasePlaceholder(self)
}
}
pub fn constant_match(&self, val: u64) -> bool {
unsafe {
Varnode_constantMatch(self, val)
}
}
pub fn contains(&self, op: &Varnode) -> i32 {
unsafe {
Varnode_contains(self, op)
}
}
pub fn copy_symbol(&mut self, vn: &Varnode) {
unsafe {
Varnode_copySymbol(self, vn)
}
}
pub fn copy_symbol_if_valid(&mut self, vn: &Varnode) {
unsafe {
Varnode_copySymbolIfValid(self, vn)
}
}
pub fn end_descend(&self) -> StdConstIterPtrPcodeOp {
unsafe {
let mut retval = MaybeUninit::uninit();
Varnode_endDescend(self, retval.as_mut_ptr());
retval.assume_init()
}
}
pub fn get_addr(&self) -> Option<&Address> {
unsafe {
Varnode_getAddr(self).as_ref()
}
}
pub fn get_consume(&self) -> u64 {
unsafe {
Varnode_getConsume(self)
}
}
pub fn get_def(&mut self) -> Option<&mut PcodeOp> {
unsafe {
Varnode_getDef(self).as_mut()
}
}
pub fn get_n_z_mask(&self) -> u64 {
unsafe {
Varnode_getNZMask(self)
}
}
pub fn get_offset(&self) -> u64 {
unsafe {
Varnode_getOffset(self)
}
}
pub fn get_size(&self) -> i32 {
unsafe {
Varnode_getSize(self)
}
}
pub fn get_space(&self) -> Option<&mut AddrSpace> {
unsafe {
Varnode_getSpace(self).as_mut()
}
}
pub fn get_space_from_const(&self) -> Option<&mut AddrSpace> {
unsafe {
Varnode_getSpaceFromConst(self).as_mut()
}
}
pub fn get_structured_type(&self) -> Option<&mut Datatype> {
unsafe {
Varnode_getStructuredType(self).as_mut()
}
}
pub fn get_symbol_entry(&self) -> Option<&mut SymbolEntry> {
unsafe {
Varnode_getSymbolEntry(self).as_mut()
}
}
pub fn get_type(&self) -> Option<&mut Datatype> {
unsafe {
Varnode_getType(self).as_mut()
}
}
pub fn get_type_def_facing(&self) -> Option<&mut Datatype> {
unsafe {
Varnode_getTypeDefFacing(self).as_mut()
}
}
pub fn get_type_read_facing(&self, op: &PcodeOp) -> Option<&mut Datatype> {
unsafe {
Varnode_getTypeReadFacing(self, op).as_mut()
}
}
pub fn has_no_descend(&self) -> bool {
unsafe {
Varnode_hasNoDescend(self)
}
}
pub fn has_no_local_alias(&self) -> bool {
unsafe {
Varnode_hasNoLocalAlias(self)
}
}
pub fn is_addr_force(&self) -> bool {
unsafe {
Varnode_isAddrForce(self)
}
}
pub fn is_addr_tied(&self) -> bool {
unsafe {
Varnode_isAddrTied(self)
}
}
pub fn is_auto_live(&self) -> bool {
unsafe {
Varnode_isAutoLive(self)
}
}
pub fn is_boolean_value(&self, useAnnotation: bool) -> bool {
unsafe {
Varnode_isBooleanValue(self, useAnnotation)
}
}
pub fn is_constant(&self) -> bool {
unsafe {
Varnode_isConstant(self)
}
}
pub fn is_constant_extended(&self, val: &mut u64) -> bool {
unsafe {
Varnode_isConstantExtended(self, val)
}
}
pub fn is_free(&self) -> bool {
unsafe {
Varnode_isFree(self)
}
}
pub fn is_heritage_known(&self) -> bool {
unsafe {
Varnode_isHeritageKnown(self)
}
}
pub fn is_indirect_zero(&self) -> bool {
unsafe {
Varnode_isIndirectZero(self)
}
}
pub fn is_input(&self) -> bool {
unsafe {
Varnode_isInput(self)
}
}
pub fn is_mark(&self) -> bool {
unsafe {
Varnode_isMark(self)
}
}
pub fn is_name_lock(&self) -> bool {
unsafe {
Varnode_isNameLock(self)
}
}
pub fn is_persist(&self) -> bool {
unsafe {
Varnode_isPersist(self)
}
}
pub fn is_precis_hi(&self) -> bool {
unsafe {
Varnode_isPrecisHi(self)
}
}
pub fn is_precis_lo(&self) -> bool {
unsafe {
Varnode_isPrecisLo(self)
}
}
pub fn is_proto_partial(&self) -> bool {
unsafe {
Varnode_isProtoPartial(self)
}
}
pub fn is_ptr_flow(&self) -> bool {
unsafe {
Varnode_isPtrFlow(self)
}
}
pub fn is_spacebase(&self) -> bool {
unsafe {
Varnode_isSpacebase(self)
}
}
pub fn is_spacebase_placeholder(&self) -> bool {
unsafe {
Varnode_isSpacebasePlaceholder(self)
}
}
pub fn is_type_lock(&self) -> bool {
unsafe {
Varnode_isTypeLock(self)
}
}
pub fn is_written(&self) -> bool {
unsafe {
Varnode_isWritten(self)
}
}
pub fn lone_descend(&self) -> Option<&mut PcodeOp> {
unsafe {
Varnode_loneDescend(self).as_mut()
}
}
pub fn overlap(&self, op: &Varnode) -> i32 {
unsafe {
Varnode_overlap(self, op)
}
}
pub fn set_mark(&self) {
unsafe {
Varnode_setMark(self)
}
}
pub fn set_proto_partial(&mut self) {
unsafe {
Varnode_setProtoPartial(self)
}
}
pub fn set_ptr_flow(&mut self) {
unsafe {
Varnode_setPtrFlow(self)
}
}
pub fn set_stack_store(&mut self) {
unsafe {
Varnode_setStackStore(self)
}
}
pub fn update_type(&mut self, ct: &mut Datatype) -> bool {
unsafe {
Varnode_updateType(self, ct)
}
}
pub fn update_type1(&mut self, ct: &mut Datatype, lock: bool, over: bool) -> bool {
unsafe {
Varnode_updateType1(self, ct, lock, over)
}
}
}
impl VarnodeData {
pub fn get_addr(&self) -> Address {
unsafe {
let mut retval = MaybeUninit::uninit();
VarnodeData_getAddr(self, retval.as_mut_ptr());
retval.assume_init()
}
}
}