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
135
136
137
138
139
140
141
142
143
144
145

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

SBCommunicationRef
CreateSBCommunication()
{
    return reinterpret_cast<SBCommunicationRef>(new SBCommunication());
}

SBCommunicationRef
CreateSBCommunication2(const char *broadcaster_name)
{
    return reinterpret_cast<SBCommunicationRef>(new SBCommunication(broadcaster_name));
}

void
DisposeSBCommunication(SBCommunicationRef instance)
{
    delete reinterpret_cast<SBCommunication *>(instance);
}

bool
SBCommunicationIsValid(SBCommunicationRef instance)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->IsValid();
}

SBBroadcasterRef
SBCommunicationGetBroadcaster(SBCommunicationRef instance)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return reinterpret_cast<SBBroadcasterRef>(new SBBroadcaster(unwrapped->GetBroadcaster()));
}

const char *
SBCommunicationGetBroadcasterClass()
{
    return lldb::SBCommunication::GetBroadcasterClass();
}

enum lldb::ConnectionStatus
SBCommunicationAdoptFileDesriptor(SBCommunicationRef instance, int fd, bool owns_fd)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->AdoptFileDesriptor(fd, owns_fd);
}

enum lldb::ConnectionStatus
SBCommunicationConnect(SBCommunicationRef instance, const char *url)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->Connect(url);
}

enum lldb::ConnectionStatus
SBCommunicationDisconnect(SBCommunicationRef instance)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->Disconnect();
}

bool
SBCommunicationIsConnected(SBCommunicationRef instance)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->IsConnected();
}

bool
SBCommunicationGetCloseOnEOF(SBCommunicationRef instance)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->GetCloseOnEOF();
}

void
SBCommunicationSetCloseOnEOF(SBCommunicationRef instance, bool b)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    unwrapped->SetCloseOnEOF(b);
}

unsigned int
SBCommunicationRead(SBCommunicationRef instance, void *dst, size_t dst_len, uint32_t timeout_usec,
                        lldb::ConnectionStatus status)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->Read(dst, dst_len, timeout_usec, status);
}

unsigned int
SBCommunicationWrite(SBCommunicationRef instance, void *src, size_t src_len, lldb::ConnectionStatus status)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->Write(src, src_len, status);
}

bool
SBCommunicationReadThreadStart(SBCommunicationRef instance)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->ReadThreadStart();
}

bool
SBCommunicationReadThreadStop(SBCommunicationRef instance)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->ReadThreadStop();
}

bool
SBCommunicationReadThreadIsRunning(SBCommunicationRef instance)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->ReadThreadIsRunning();
}

bool
SBCommunicationSetReadThreadBytesReceivedCallback(SBCommunicationRef instance, ReadThreadBytesReceived callback,
                                                      void *callback_baton)
{
    SBCommunication *unwrapped = reinterpret_cast<SBCommunication *>(instance);
    return unwrapped->SetReadThreadBytesReceivedCallback(callback, callback_baton);
}

#ifdef __cplusplus
}
#endif