{

BNDisassemblyTextLineTypeInfo result;

result.hasTypeInfo = this->hasTypeInfo;

result.parentType = this->parentType ? BNNewTypeReference(this->parentType->GetObject()) : nullptr;

result.fieldIndex = this->fieldIndex;

result.offset = this->offset;

return result;

{

DisassemblyTextLineTypeInfo result;

result.hasTypeInfo = value->hasTypeInfo;

result.fieldIndex = value->fieldIndex;

result.parentType = value->parentType ? new Type(BNNewTypeReference(value->parentType)) : nullptr;

result.offset = value->offset;

return result;

{

addr = 0;

instrIndex = BN_INVALID_EXPR;

highlight.style = StandardHighlightColor;

highlight.color = NoHighlightColor;

highlight.mixColor = NoHighlightColor;

highlight.mix = 0;

highlight.r = 0;

highlight.g = 0;

highlight.b = 0;

highlight.alpha = 255;

typeInfo.hasTypeInfo = false;

typeInfo.fieldIndex = -1;

typeInfo.parentType = nullptr;

typeInfo.offset = 0;

{

BNDisassemblyTextLine result;

result.addr = this->addr;

result.instrIndex = this->instrIndex;

result.highlight = this->highlight;

result.tokens = InstructionTextToken::CreateInstructionTextTokenList(this->tokens);

result.count = this->tokens.size();

result.tags = Tag::CreateTagList(this->tags, &(result.tagCount));

result.typeInfo = this->typeInfo.GetAPIObject();

return result;

{

InstructionTextToken::FreeInstructionTextTokenList(value->tokens, value->count);

Tag::FreeTagList(value->tags, value->tagCount);

DisassemblyTextLineTypeInfo::FreeAPIObject(&value->typeInfo);

{

DisassemblyTextLine result;

result.addr = value->addr;

result.instrIndex = value->instrIndex;

result.highlight = value->highlight;

result.tokens = InstructionTextToken::ConvertInstructionTextTokenList(value->tokens, value->count);

result.tags = Tag::ConvertTagList(value->tags, value->tagCount);

result.typeInfo = DisassemblyTextLineTypeInfo::FromAPIObject(&value->typeInfo);

return result;

{

size_t result = 0;

for (auto& i : tokens)

result += i.width;

return result;

const vector<InstructionTextToken>& tokens, const std::function<void(const InstructionTextToken&)>& callback)

{

size_t startToken = 0;

for (size_t i = 0; i < tokens.size(); i++)

{

if (tokens[i].type == AddressSeparatorToken)

{

startToken = i + 1;

break;

}

}

for (size_t i = 0; i < startToken; i++)

callback(tokens[i]);

for (size_t i = startToken; i < tokens.size(); i++)

{

if (tokens[i].type == AddressDisplayToken || tokens[i].type == AddressSeparatorToken

|| tokens[i].type == CollapseStateIndicatorToken)

{

callback(tokens[i]);

continue;

}

bool whitespace = true;

for (auto ch : tokens[i].text)

{

if (!isspace(ch))

{

whitespace = false;

break;

}

}

if (!whitespace)

break;

callback(tokens[i]);

}

{

size_t result = 0;

FindAddressAndIndentationTokens(tokens, [&](const InstructionTextToken& token) { result += token.width; });

return result;

{

vector<InstructionTextToken> result;

FindAddressAndIndentationTokens(tokens, [&](const InstructionTextToken& token) { result.push_back(token); });

return result;

{

size_t count;

BNBasicBlockEdge* array = BNGetBasicBlockOutgoingEdges(m_object, &count);

vector<BasicBlockEdge> result;

result.reserve(count);

for (size_t i = 0; i < count; i++)

{

BasicBlockEdge edge;

edge.type = array[i].type;

edge.target = array[i].target ? new BasicBlock(BNNewBasicBlockReference(array[i].target)) : nullptr;

edge.backEdge = array[i].backEdge;

edge.fallThrough = array[i].fallThrough;

result.push_back(edge);

}

BNFreeBasicBlockEdgeList(array, count);

return result;

{

size_t count;

BNBasicBlockEdge* array = BNGetBasicBlockIncomingEdges(m_object, &count);

vector<BasicBlockEdge> result;

result.reserve(count);

for (size_t i = 0; i < count; i++)

{

BasicBlockEdge edge;

edge.type = array[i].type;

edge.target = array[i].target ? new BasicBlock(BNNewBasicBlockReference(array[i].target)) : nullptr;

edge.backEdge = array[i].backEdge;

edge.fallThrough = array[i].fallThrough;

result.push_back(edge);

}

BNFreeBasicBlockEdgeList(array, count);

return result;

{

size_t count;

BNPendingBasicBlockEdge* edges = BNGetBasicBlockPendingOutgoingEdges(m_object, &count);

vector<PendingBasicBlockEdge> result;

result.reserve(count);

for (size_t i = 0; i < count; i++)

{

PendingBasicBlockEdge edge;

edge.type = edges[i].type;

edge.arch = edges[i].arch ? new CoreArchitecture(edges[i].arch) : nullptr;

edge.target = edges[i].target;

edge.fallThrough = edges[i].fallThrough;

result.push_back(edge);

}

BNFreePendingBasicBlockEdgeList(edges);

return result;

{

size_t count;

BNBasicBlock** blocks = BNGetBasicBlockDominators(m_object, &count, post);

set<Ref<BasicBlock>> result;

for (size_t i = 0; i < count; i++)

result.insert(new BasicBlock(BNNewBasicBlockReference(blocks[i])));

BNFreeBasicBlockList(blocks, count);

return result;

{

size_t count;

BNBasicBlock** blocks = BNGetBasicBlockStrictDominators(m_object, &count, post);

set<Ref<BasicBlock>> result;

for (size_t i = 0; i < count; i++)

result.insert(new BasicBlock(BNNewBasicBlockReference(blocks[i])));

BNFreeBasicBlockList(blocks, count);

return result;

{

BNBasicBlock* result = BNGetBasicBlockImmediateDominator(m_object, post);

if (!result)

return nullptr;

return new BasicBlock(result);

{

size_t count;

BNBasicBlock** blocks = BNGetBasicBlockDominatorTreeChildren(m_object, &count, post);

set<Ref<BasicBlock>> result;

for (size_t i = 0; i < count; i++)

result.insert(new BasicBlock(BNNewBasicBlockReference(blocks[i])));

BNFreeBasicBlockList(blocks, count);

return result;

{

size_t count;

BNBasicBlock** blocks = BNGetBasicBlockDominanceFrontier(m_object, &count, post);

set<Ref<BasicBlock>> result;

for (size_t i = 0; i < count; i++)

result.insert(new BasicBlock(BNNewBasicBlockReference(blocks[i])));

BNFreeBasicBlockList(blocks, count);

return result;

{

BNBasicBlock** blockSet = new BNBasicBlock*[blocks.size()];

size_t i = 0;

for (auto& j : blocks)

blockSet[i++] = j->GetObject();

size_t count;

BNBasicBlock** resultBlocks = BNGetBasicBlockIteratedDominanceFrontier(blockSet, blocks.size(), &count);

delete[] blockSet;

set<Ref<BasicBlock>> result;

for (size_t k = 0; k < count; k++)

result.insert(new BasicBlock(BNNewBasicBlockReference(resultBlocks[k])));

BNFreeBasicBlockList(resultBlocks, count);

return result;

{

size_t count;

BNDisassemblyTextLine* lines = BNGetBasicBlockDisassemblyText(m_object, settings->GetObject(), &count);

vector<DisassemblyTextLine> result = ParseAPIObjectList<DisassemblyTextLine>(lines, count);;

BNFreeDisassemblyTextLines(lines, count);

return result;

{

BNHighlightColor hc;

hc.style = StandardHighlightColor;

hc.color = color;

hc.mixColor = NoHighlightColor;

hc.mix = 0;

hc.r = 0;

hc.g = 0;

hc.b = 0;

hc.alpha = alpha;

SetAutoBasicBlockHighlight(hc);

BNHighlightStandardColor color, BNHighlightStandardColor mixColor, uint8_t mix, uint8_t alpha)

{

BNHighlightColor hc;

hc.style = MixedHighlightColor;

hc.color = color;

hc.mixColor = mixColor;

hc.mix = mix;

hc.r = 0;

hc.g = 0;

hc.b = 0;

hc.alpha = alpha;

SetAutoBasicBlockHighlight(hc);

{

BNHighlightColor hc;

hc.style = CustomHighlightColor;

hc.color = NoHighlightColor;

hc.mixColor = NoHighlightColor;

hc.mix = 0;

hc.r = r;

hc.g = g;

hc.b = b;

hc.alpha = alpha;

SetAutoBasicBlockHighlight(hc);

{

BNHighlightColor hc;

hc.style = StandardHighlightColor;

hc.color = color;

hc.mixColor = NoHighlightColor;

hc.mix = 0;

hc.r = 0;

hc.g = 0;

hc.b = 0;

hc.alpha = alpha;

SetUserBasicBlockHighlight(hc);

BNHighlightStandardColor color, BNHighlightStandardColor mixColor, uint8_t mix, uint8_t alpha)

{

BNHighlightColor hc;

hc.style = MixedHighlightColor;

hc.color = color;

hc.mixColor = mixColor;

hc.mix = mix;

hc.r = 0;

hc.g = 0;

hc.b = 0;

hc.alpha = alpha;

SetUserBasicBlockHighlight(hc);

{

BNHighlightColor hc;

hc.style = CustomHighlightColor;

hc.color = NoHighlightColor;

hc.mixColor = NoHighlightColor;

hc.mix = 0;

hc.r = r;

hc.g = g;

hc.b = b;

hc.alpha = alpha;

SetUserBasicBlockHighlight(hc);

{

for (auto& i : source->GetOutgoingEdges())

{

if (i.target->GetObject() == target->GetObject())

return i.backEdge;

}

return false;

{

BNLowLevelILFunction* func = BNGetBasicBlockLowLevelILFunction(m_object);

if (!func)

return nullptr;

return new LowLevelILFunction(func);

{

BNMediumLevelILFunction* func = BNGetBasicBlockMediumLevelILFunction(m_object);

if (!func)

return nullptr;

return new MediumLevelILFunction(func);

{

BNHighLevelILFunction* func = BNGetBasicBlockHighLevelILFunction(m_object);

if (!func)

return nullptr;

return new HighLevelILFunction(func);

{

BNBasicBlock* block = BNGetBasicBlockSourceBlock(m_object);

if (!block)

return nullptr;

return new BasicBlock(block);