lldb-sys 0.0.13

Raw bindings to the LLDB C++ API. LLDB is the debugger that is part of the LLVM project and is the default system debugger on Mac OS X. Building and using this is currently slightly tricky, so be sure to see the README.md in the repository.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

//===-- SBErrorBinding.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"
#include "stdarg.h"

using namespace lldb;

#ifdef __cplusplus
extern "C" {
#endif

SBErrorRef
CreateSBError()
{
    return reinterpret_cast<SBErrorRef>(new SBError());
}

void
DisposeSBError(SBErrorRef instance)
{
    delete reinterpret_cast<SBError *>(instance);
}

const char *
SBErrorGetCString(SBErrorRef instance)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    return unwrapped->GetCString();
}

void
SBErrorClear(SBErrorRef instance)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    unwrapped->Clear();
}

bool
SBErrorFail(SBErrorRef instance)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    return unwrapped->Fail();
}

bool
SBErrorSuccess(SBErrorRef instance)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    return unwrapped->Success();
}

unsigned int
SBErrorGetError(SBErrorRef instance)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    return unwrapped->GetError();
}

enum lldb::ErrorType
SBErrorGetType(SBErrorRef instance)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    return unwrapped->GetType();
}

void
SBErrorSetError(SBErrorRef instance, uint32_t err, lldb::ErrorType type)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    unwrapped->SetError(err, type);
}

void
SBErrorSetErrorToErrno(SBErrorRef instance)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    unwrapped->SetErrorToErrno();
}

void
SBErrorSetErrorToGenericError(SBErrorRef instance)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    unwrapped->SetErrorToGenericError();
}

void
SBErrorSetErrorString(SBErrorRef instance, const char *err_str)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    unwrapped->SetErrorString(err_str);
}

int
SBErrorSetErrorStringWithFormat(SBErrorRef instance, const char *format, ...)
{
    if (!format)
        return 0;

    int retVal;
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);

    va_list args;
    va_start(args, format);
    retVal = unwrapped->SetErrorStringWithFormat(format, args);
    va_end(args);
    return retVal;
}

bool
SBErrorIsValid(SBErrorRef instance)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    return unwrapped->IsValid();
}

bool
SBErrorGetDescription(SBErrorRef instance, SBStreamRef description)
{
    SBError *unwrapped = reinterpret_cast<SBError *>(instance);
    return unwrapped->GetDescription(*reinterpret_cast<SBStream *>(description));
}

#ifdef __cplusplus
}
#endif