lldb-sys 0.0.31

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.
Documentation 
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

//===-- 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/API/LLDB.h"
#include "lldb/Bindings/LLDBBinding.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
SBCommunicationAdoptFileDescriptor(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);
}

size_t 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);
}

size_t 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