lldb-sys 0.0.13

//===-- SBFrameBinding.cpp --------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "lldb/Bindings/LLDBBinding.h"
#include "lldb/API/LLDB.h"

using namespace lldb;

#ifdef __cplusplus
extern "C" {
#endif

SBFrameRef
CreateSBFrame()
{
    return reinterpret_cast<SBFrameRef>(new SBFrame());
}

void
DisposeSBFrame(SBFrameRef instance)
{
    delete reinterpret_cast<SBFrame *>(instance);
}

bool
SBFrameIsEqual(SBFrameRef instance, SBFrameRef that)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->IsEqual(*reinterpret_cast<SBFrame *>(that));
}

bool
SBFrameIsValid(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->IsValid();
}

unsigned int
SBFrameGetFrameID(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->GetFrameID();
}

unsigned long long
SBFrameGetCFA(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->GetCFA();
}

unsigned long long
SBFrameGetPC(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->GetPC();
}

bool
SBFrameSetPC(SBFrameRef instance, lldb_addr_t new_pc)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->SetPC(new_pc);
}

unsigned long long
SBFrameGetSP(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->GetSP();
}

unsigned long long
SBFrameGetFP(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->GetFP();
}

SBAddressRef
SBFrameGetPCAddress(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBAddressRef>(new SBAddress(unwrapped->GetPCAddress()));
}

SBSymbolContextRef
SBFrameGetSymbolContext(SBFrameRef instance, uint32_t resolve_scope)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBSymbolContextRef>(new SBSymbolContext(unwrapped->GetSymbolContext(resolve_scope)));
}

SBModuleRef
SBFrameGetModule(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBModuleRef>(new SBModule(unwrapped->GetModule()));
}

SBCompileUnitRef
SBFrameGetCompileUnit(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBCompileUnitRef>(new SBCompileUnit(unwrapped->GetCompileUnit()));
}

SBFunctionRef
SBFrameGetFunction(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBFunctionRef>(new SBFunction(unwrapped->GetFunction()));
}

SBSymbolRef
SBFrameGetSymbol(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBSymbolRef>(new SBSymbol(unwrapped->GetSymbol()));
}

SBBlockRef
SBFrameGetBlock(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBBlockRef>(new SBBlock(unwrapped->GetBlock()));
}

const char *
SBFrameGetFunctionName(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->GetFunctionName();
}

const char *
SBFrameGetDisplayFunctionName(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->GetDisplayFunctionName();
}

bool
SBFrameIsInlined(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->IsInlined();
}

SBValueRef
SBFrameEvaluateExpression(SBFrameRef instance, const char *expr, SBExpressionOptionsRef options)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueRef>(
        new SBValue(unwrapped->EvaluateExpression(expr, *reinterpret_cast<SBExpressionOptions *>(options))));
}

SBBlockRef
SBFrameGetFrameBlock(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBBlockRef>(new SBBlock(unwrapped->GetFrameBlock()));
}

SBLineEntryRef
SBFrameGetLineEntry(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBLineEntryRef>(new SBLineEntry(unwrapped->GetLineEntry()));
}

SBThreadRef
SBFrameGetThread(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBThreadRef>(new SBThread(unwrapped->GetThread()));
}

const char *
SBFrameDisassemble(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->Disassemble();
}

void
SBFrameClear(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    unwrapped->Clear();
}

SBValueListRef
SBFrameGetVariables(SBFrameRef instance, SBVariablesOptionsRef options)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueListRef>(
        new SBValueList(unwrapped->GetVariables(*reinterpret_cast<SBVariablesOptions *>(options))));
}

SBValueListRef
SBFrameGetRegisters(SBFrameRef instance)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueListRef>(new SBValueList(unwrapped->GetRegisters()));
}

SBValueRef
SBFrameFindRegister(SBFrameRef instance, const char *name)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueRef>(new SBValue(unwrapped->FindRegister(name)));
}

SBValueRef
SBFrameFindVariable(SBFrameRef instance, const char *var_name)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueRef>(new SBValue(unwrapped->FindVariable(var_name)));
}

SBValueRef
SBFrameFindVariable2(SBFrameRef instance, const char *var_name, lldb::DynamicValueType use_dynamic)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueRef>(new SBValue(unwrapped->FindVariable(var_name, use_dynamic)));
}

SBValueRef
SBFrameGetValueForVariablePath(SBFrameRef instance, const char *var_expr_cstr,
                                   enum lldb::DynamicValueType use_dynamic)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueRef>(
        new SBValue(unwrapped->GetValueForVariablePath(var_expr_cstr, use_dynamic)));
}

SBValueRef
SBFrameGetValueForVariablePath2(SBFrameRef instance, const char *var_path)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueRef>(new SBValue(unwrapped->GetValueForVariablePath(var_path)));
}

SBValueRef
SBFrameFindValue(SBFrameRef instance, const char *name, enum lldb::ValueType value_type)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueRef>(new SBValue(unwrapped->FindValue(name, value_type)));
}

SBValueRef
SBFrameFindValue2(SBFrameRef instance, const char *name, enum lldb::ValueType value_type,
                      lldb::DynamicValueType use_dynamic)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return reinterpret_cast<SBValueRef>(new SBValue(unwrapped->FindValue(name, value_type, use_dynamic)));
}

bool
SBFrameGetDescription(SBFrameRef instance, SBStreamRef description)
{
    SBFrame *unwrapped = reinterpret_cast<SBFrame *>(instance);
    return unwrapped->GetDescription(*reinterpret_cast<SBStream *>(description));
}

#ifdef __cplusplus
}
#endif