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
120
121
122
123
124
125
126
127
128
129
130
131
132
133

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

#ifndef LLDB_SBBreakpointNameBinding_h_
#define LLDB_SBBreakpointNameBinding_h_

#include "lldb/Bindings/SBBindingDefines.h"

#ifdef __cplusplus
extern "C" {
#endif

LLDB_API SBBreakpointNameRef CreateSBBreakpointName(void);

LLDB_API SBBreakpointNameRef
CreateSBBreakpointNameFromTarget(SBTargetRef target, const char *name);

LLDB_API SBBreakpointNameRef CreateSBBreakpointNameFromBreakpoint(
    SBBreakpointRef breakpoint, const char *name);

LLDB_API SBBreakpointNameRef
CloneSBBreakpointName(SBBreakpointNameRef instance);

LLDB_API void DisposeSBBreakpointName(SBBreakpointNameRef instance);

LLDB_API bool SBBreakpointNameIsValid(SBBreakpointNameRef instance);

LLDB_API const char *
SBBreakpointNameGetName(SBBreakpointNameRef instance) const;

LLDB_API void SBBreakpointNameSetEnabled(SBBreakpointNameRef instance,
                                         bool enable);

LLDB_API bool SBBreakpointNameIsEnabled(SBBreakpointNameRef instance);

LLDB_API void SBBreakpointNameSetOneShot(SBBreakpointNameRef instance,
                                         bool one_shot);

LLDB_API bool SBBreakpointNameIsOneShot(SBBreakpointNameRef instance) const;

LLDB_API void SBBreakpointNameSetIgnoreCount(SBBreakpointNameRef instance,
                                             uint32_t count);

LLDB_API uint32_t
SBBreakpointNameGetIgnoreCount(SBBreakpointNameRef instance) const;

LLDB_API void SBBreakpointNameSetCondition(SBBreakpointNameRef instance,
                                           const char *condition);

LLDB_API const char *SBBreakpointNameGetCondition(SBBreakpointNameRef instance);

LLDB_API void SBBreakpointNameSetAutoContinue(SBBreakpointNameRef instance,
                                              bool auto_continue);

LLDB_API bool SBBreakpointNameGetAutoContinue(SBBreakpointNameRef instance);

LLDB_API void SBBreakpointNameSetThreadID(SBBreakpointNameRef instance,
                                          lldb_tid_t sb_thread_id);

LLDB_API lldb_tid_t SBBreakpointNameGetThreadID(SBBreakpointNameRef instance);

LLDB_API void SBBreakpointNameSetThreadIndex(SBBreakpointNameRef instance,
                                             uint32_t index);

LLDB_API uint32_t
SBBreakpointNameGetThreadIndex(SBBreakpointNameRef instance) const;

LLDB_API void SBBreakpointNameSetThreadName(SBBreakpointNameRef instance,
                                            const char *thread_name);

LLDB_API const char *
SBBreakpointNameGetThreadName(SBBreakpointNameRef instance) const;

LLDB_API void SBBreakpointNameSetQueueName(SBBreakpointNameRef instance,
                                           const char *queue_name);

LLDB_API const char *
SBBreakpointNameGetQueueName(SBBreakpointNameRef instance) const;

LLDB_API void SBBreakpointNameSetCallback(SBBreakpointNameRef instance,
                                          SBBreakpointHitCallback callback,
                                          void *baton);

LLDB_API SBErrorRef SBBreakpointNameSetScriptCallbackFunction(
    SBBreakpointRef instance, const char *callback_function_name,
    SBStructuredDataRef extra_args);

LLDB_API void
SBBreakpointNameSetCommandLineCommands(SBBreakpointNameRef instance,
                                       SBStringListRef commands);

LLDB_API bool
SBBreakpointNameGetCommandLineCommands(SBBreakpointNameRef instance,
                                       SBStringListRef commands);

LLDB_API SBErrorRef SBBreakpointNameSetScriptCallbackBody(
    SBBreakpointNameRef instance, const char *script_body_text);

LLDB_API const char *
SBBreakpointNameGetHelpString(SBBreakpointNameRef instance) const;

LLDB_API void SBBreakpointNameSetHelpString(SBBreakpointNameRef instance,
                                            const char *help_string);

LLDB_API bool SBBreakpointNameGetAllowList(SBBreakpointNameRef instance) const;

LLDB_API void SBBreakpointNameSetAllowList(SBBreakpointNameRef instance,
                                           bool value);

LLDB_API bool SBBreakpointNameGetAllowDelete(SBBreakpointNameRef instance);

LLDB_API void SBBreakpointNameSetAllowDelete(SBBreakpointNameRef instance,
                                             bool value);

LLDB_API bool SBBreakpointNameGetAllowDisable(SBBreakpointNameRef instance);

LLDB_API void SBBreakpointNameSetAllowDisable(SBBreakpointNameRef instance,
                                              bool value);

LLDB_API bool SBBreakpointNameGetDescription(SBBreakpointNameRef instance,
                                             SBStreamRef description);

#ifdef __cplusplus
}
#endif

#endif // LLDB_SBBreakpointNameBinding_h_