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

//===-- SBEventBinding.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

SBEventRef
CreateSBEvent()
{
    return reinterpret_cast<SBEventRef>(new SBEvent());
}

SBEventRef
CreateSBEvent2(uint32_t event, const char *cstr, uint32_t cstr_len)
{
    return reinterpret_cast<SBEventRef>(new SBEvent(event, cstr, cstr_len));
}

void
DisposeSBEvent(SBEventRef instance)
{
    delete reinterpret_cast<SBEvent *>(instance);
}

bool
SBEventIsValid(SBEventRef instance)
{
    SBEvent *unwrapped = reinterpret_cast<SBEvent *>(instance);
    return unwrapped->IsValid();
}

const char *
SBEventGetDataFlavor(SBEventRef instance)
{
    SBEvent *unwrapped = reinterpret_cast<SBEvent *>(instance);
    return unwrapped->GetDataFlavor();
}

unsigned int
SBEventGetType(SBEventRef instance)
{
    SBEvent *unwrapped = reinterpret_cast<SBEvent *>(instance);
    return unwrapped->GetType();
}

SBBroadcasterRef
SBEventGetBroadcaster(SBEventRef instance)
{
    SBEvent *unwrapped = reinterpret_cast<SBEvent *>(instance);
    return reinterpret_cast<SBBroadcasterRef>(new SBBroadcaster(unwrapped->GetBroadcaster()));
}

const char *
SBEventGetBroadcasterClass(SBEventRef instance)
{
    SBEvent *unwrapped = reinterpret_cast<SBEvent *>(instance);
    return unwrapped->GetBroadcasterClass();
}

bool
SBEventBroadcasterMatchesPtr(SBEventRef instance, SBBroadcasterRef broadcaster)
{
    SBEvent *unwrapped = reinterpret_cast<SBEvent *>(instance);
    return unwrapped->BroadcasterMatchesPtr(reinterpret_cast<SBBroadcaster *>(broadcaster));
}

bool
SBEventBroadcasterMatchesRef(SBEventRef instance, SBBroadcasterRef broadcaster)
{
    SBEvent *unwrapped = reinterpret_cast<SBEvent *>(instance);
    return unwrapped->BroadcasterMatchesRef(*reinterpret_cast<SBBroadcaster *>(broadcaster));
}

void
SBEventClear(SBEventRef instance)
{
    SBEvent *unwrapped = reinterpret_cast<SBEvent *>(instance);
    unwrapped->Clear();
}

const char *
SBEventGetCStringFromEvent(SBEventRef event)
{
    return lldb::SBEvent::GetCStringFromEvent(*reinterpret_cast<SBEvent *>(event));
}

bool
SBEventGetDescription(SBEventRef instance, SBStreamRef description)
{
    SBEvent *unwrapped = reinterpret_cast<SBEvent *>(instance);
    return unwrapped->GetDescription(*reinterpret_cast<SBStream *>(description));
}

#ifdef __cplusplus
}
#endif