← Back to branch summary

~ubuntu-branches/ubuntu/trusty/llvm-toolchain-snapshot/trusty-201310232150

« back to all changes in this revision

Viewing changes to lldb/include/lldb/Core/PluginManager.h

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2013-05-27 15:01:57 UTC
  • mfrom: (0.10.1) (0.9.1) (0.8.1) (0.7.1) (0.6.1) (0.5.2)
  • Revision ID: package-import@ubuntu.com-20130527150157-tdkrsjpuvht7v0qx
Tags: 1:3.4~svn182733-1~exp1
http://bugs.debian.org/708677
* New snapshot release (3.4 release)
* Add a symlink of libLLVM-3.4.so.1 to usr/lib/llvm-3.4/lib/libLLVM-3.4.so
    to fix make the llvm-config-3.4 --libdir work (Closes: #708677)
  * Various packages rename to allow co installations:
    * libclang1 => libclang1-3.4
    * libclang1-dbg => libclang1-3.4-dbg
    * libclang-dev => libclang-3.4-dev
    * libclang-common-dev => libclang-common-3.4-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
lldb/include/lldb/Core/PluginManager.h
29
29
    // ABI
30
30
    //------------------------------------------------------------------
31
31
    static bool
32
 
    RegisterPlugin (const char *name,
 
32
    RegisterPlugin (const ConstString &name,
33
33
                    const char *description,
34
34
                    ABICreateInstance create_callback);
35
35
 
40
40
    GetABICreateCallbackAtIndex (uint32_t idx);
41
41
 
42
42
    static ABICreateInstance
43
 
    GetABICreateCallbackForPluginName (const char *name);
 
43
    GetABICreateCallbackForPluginName (const ConstString &name);
44
44
 
45
45
 
46
46
    //------------------------------------------------------------------
47
47
    // Disassembler
48
48
    //------------------------------------------------------------------
49
49
    static bool
50
 
    RegisterPlugin (const char *name,
 
50
    RegisterPlugin (const ConstString &name,
51
51
                    const char *description,
52
52
                    DisassemblerCreateInstance create_callback);
53
53
 
58
58
    GetDisassemblerCreateCallbackAtIndex (uint32_t idx);
59
59
 
60
60
    static DisassemblerCreateInstance
61
 
    GetDisassemblerCreateCallbackForPluginName (const char *name);
 
61
    GetDisassemblerCreateCallbackForPluginName (const ConstString &name);
62
62
 
63
63
 
64
64
    //------------------------------------------------------------------
65
65
    // DynamicLoader
66
66
    //------------------------------------------------------------------
67
67
    static bool
68
 
    RegisterPlugin (const char *name,
 
68
    RegisterPlugin (const ConstString &name,
69
69
                    const char *description,
70
70
                    DynamicLoaderCreateInstance create_callback,
71
71
                    DebuggerInitializeCallback debugger_init_callback = NULL);
77
77
    GetDynamicLoaderCreateCallbackAtIndex (uint32_t idx);
78
78
 
79
79
    static DynamicLoaderCreateInstance
80
 
    GetDynamicLoaderCreateCallbackForPluginName (const char *name);
 
80
    GetDynamicLoaderCreateCallbackForPluginName (const ConstString &name);
81
81
 
82
82
    //------------------------------------------------------------------
83
83
    // EmulateInstruction
84
84
    //------------------------------------------------------------------
85
85
    static bool
86
 
    RegisterPlugin (const char *name,
 
86
    RegisterPlugin (const ConstString &name,
87
87
                    const char *description,
88
88
                    EmulateInstructionCreateInstance create_callback);
89
89
    
94
94
    GetEmulateInstructionCreateCallbackAtIndex (uint32_t idx);
95
95
    
96
96
    static EmulateInstructionCreateInstance
97
 
    GetEmulateInstructionCreateCallbackForPluginName (const char *name);
 
97
    GetEmulateInstructionCreateCallbackForPluginName (const ConstString &name);
98
98
 
99
99
    //------------------------------------------------------------------
100
100
    // OperatingSystem
101
101
    //------------------------------------------------------------------
102
102
    static bool
103
 
    RegisterPlugin (const char *name,
 
103
    RegisterPlugin (const ConstString &name,
104
104
                    const char *description,
105
105
                    OperatingSystemCreateInstance create_callback);
106
106
    
111
111
    GetOperatingSystemCreateCallbackAtIndex (uint32_t idx);
112
112
    
113
113
    static OperatingSystemCreateInstance
114
 
    GetOperatingSystemCreateCallbackForPluginName (const char *name);
 
114
    GetOperatingSystemCreateCallbackForPluginName (const ConstString &name);
115
115
 
116
116
    //------------------------------------------------------------------
117
117
    // LanguageRuntime
118
118
    //------------------------------------------------------------------
119
119
    static bool
120
 
    RegisterPlugin (const char *name,
 
120
    RegisterPlugin (const ConstString &name,
121
121
                    const char *description,
122
122
                    LanguageRuntimeCreateInstance create_callback);
123
123
 
128
128
    GetLanguageRuntimeCreateCallbackAtIndex (uint32_t idx);
129
129
 
130
130
    static LanguageRuntimeCreateInstance
131
 
    GetLanguageRuntimeCreateCallbackForPluginName (const char *name);
 
131
    GetLanguageRuntimeCreateCallbackForPluginName (const ConstString &name);
132
132
 
133
133
 
134
134
    //------------------------------------------------------------------
135
135
    // ObjectFile
136
136
    //------------------------------------------------------------------
137
137
    static bool
138
 
    RegisterPlugin (const char *name,
 
138
    RegisterPlugin (const ConstString &name,
139
139
                    const char *description,
140
140
                    ObjectFileCreateInstance create_callback,
141
 
                    ObjectFileCreateMemoryInstance create_memory_callback);
 
141
                    ObjectFileCreateMemoryInstance create_memory_callback,
 
142
                    ObjectFileGetModuleSpecifications get_module_specifications);
142
143
 
143
144
    static bool
144
145
    UnregisterPlugin (ObjectFileCreateInstance create_callback);
149
150
    static ObjectFileCreateMemoryInstance
150
151
    GetObjectFileCreateMemoryCallbackAtIndex (uint32_t idx);
151
152
 
 
153
    static ObjectFileGetModuleSpecifications
 
154
    GetObjectFileGetModuleSpecificationsCallbackAtIndex (uint32_t idx);
 
155
 
152
156
    static ObjectFileCreateInstance
153
 
    GetObjectFileCreateCallbackForPluginName (const char *name);
 
157
    GetObjectFileCreateCallbackForPluginName (const ConstString &name);
154
158
 
155
159
    static ObjectFileCreateMemoryInstance
156
 
    GetObjectFileCreateMemoryCallbackForPluginName (const char *name);
 
160
    GetObjectFileCreateMemoryCallbackForPluginName (const ConstString &name);
157
161
 
158
162
 
159
163
    //------------------------------------------------------------------
160
164
    // ObjectContainer
161
165
    //------------------------------------------------------------------
162
166
    static bool
163
 
    RegisterPlugin (const char *name,
 
167
    RegisterPlugin (const ConstString &name,
164
168
                    const char *description,
165
 
                    ObjectContainerCreateInstance create_callback);
 
169
                    ObjectContainerCreateInstance create_callback,
 
170
                    ObjectFileGetModuleSpecifications get_module_specifications);
166
171
 
167
172
    static bool
168
173
    UnregisterPlugin (ObjectContainerCreateInstance create_callback);
171
176
    GetObjectContainerCreateCallbackAtIndex (uint32_t idx);
172
177
 
173
178
    static ObjectContainerCreateInstance
174
 
    GetObjectContainerCreateCallbackForPluginName (const char *name);
 
179
    GetObjectContainerCreateCallbackForPluginName (const ConstString &name);
 
180
 
 
181
    static ObjectFileGetModuleSpecifications
 
182
    GetObjectContainerGetModuleSpecificationsCallbackAtIndex (uint32_t idx);
175
183
 
176
184
    //------------------------------------------------------------------
177
185
    // LogChannel
178
186
    //------------------------------------------------------------------
179
187
    static bool
180
 
    RegisterPlugin (const char *name,
 
188
    RegisterPlugin (const ConstString &name,
181
189
                    const char *description,
182
190
                    LogChannelCreateInstance create_callback);
183
191
 
188
196
    GetLogChannelCreateCallbackAtIndex (uint32_t idx);
189
197
 
190
198
    static LogChannelCreateInstance
191
 
    GetLogChannelCreateCallbackForPluginName (const char *name);
 
199
    GetLogChannelCreateCallbackForPluginName (const ConstString &name);
192
200
 
193
201
    static const char *
194
202
    GetLogChannelCreateNameAtIndex (uint32_t idx);
197
205
    // Platform
198
206
    //------------------------------------------------------------------
199
207
    static bool
200
 
    RegisterPlugin (const char *name,
 
208
    RegisterPlugin (const ConstString &name,
201
209
                    const char *description,
202
210
                    PlatformCreateInstance create_callback,
203
211
                    DebuggerInitializeCallback debugger_init_callback = NULL);
209
217
    GetPlatformCreateCallbackAtIndex (uint32_t idx);
210
218
 
211
219
    static PlatformCreateInstance
212
 
    GetPlatformCreateCallbackForPluginName (const char *name);
 
220
    GetPlatformCreateCallbackForPluginName (const ConstString &name);
213
221
    
214
222
    static const char *
215
223
    GetPlatformPluginNameAtIndex (uint32_t idx);
224
232
    // Process
225
233
    //------------------------------------------------------------------
226
234
    static bool
227
 
    RegisterPlugin (const char *name,
 
235
    RegisterPlugin (const ConstString &name,
228
236
                    const char *description,
229
237
                    ProcessCreateInstance create_callback);
230
238
    
235
243
    GetProcessCreateCallbackAtIndex (uint32_t idx);
236
244
    
237
245
    static ProcessCreateInstance
238
 
    GetProcessCreateCallbackForPluginName (const char *name);
 
246
    GetProcessCreateCallbackForPluginName (const ConstString &name);
239
247
    
240
248
    static const char *
241
249
    GetProcessPluginNameAtIndex (uint32_t idx);
247
255
    // SymbolFile
248
256
    //------------------------------------------------------------------
249
257
    static bool
250
 
    RegisterPlugin (const char *name,
 
258
    RegisterPlugin (const ConstString &name,
251
259
                    const char *description,
252
260
                    SymbolFileCreateInstance create_callback);
253
261
 
258
266
    GetSymbolFileCreateCallbackAtIndex (uint32_t idx);
259
267
 
260
268
    static SymbolFileCreateInstance
261
 
    GetSymbolFileCreateCallbackForPluginName (const char *name);
 
269
    GetSymbolFileCreateCallbackForPluginName (const ConstString &name);
262
270
 
263
271
 
264
272
    //------------------------------------------------------------------
265
273
    // SymbolVendor
266
274
    //------------------------------------------------------------------
267
275
    static bool
268
 
    RegisterPlugin (const char *name,
 
276
    RegisterPlugin (const ConstString &name,
269
277
                    const char *description,
270
278
                    SymbolVendorCreateInstance create_callback);
271
279
 
276
284
    GetSymbolVendorCreateCallbackAtIndex (uint32_t idx);
277
285
 
278
286
    static SymbolVendorCreateInstance
279
 
    GetSymbolVendorCreateCallbackForPluginName (const char *name);
 
287
    GetSymbolVendorCreateCallbackForPluginName (const ConstString &name);
280
288
 
281
289
    //------------------------------------------------------------------
282
290
    // UnwindAssembly
283
291
    //------------------------------------------------------------------
284
292
    static bool
285
 
    RegisterPlugin (const char *name,
 
293
    RegisterPlugin (const ConstString &name,
286
294
                    const char *description,
287
295
                    UnwindAssemblyCreateInstance create_callback);
288
296
 
293
301
    GetUnwindAssemblyCreateCallbackAtIndex (uint32_t idx);
294
302
 
295
303
    static UnwindAssemblyCreateInstance
296
 
    GetUnwindAssemblyCreateCallbackForPluginName (const char *name);
 
304
    GetUnwindAssemblyCreateCallbackForPluginName (const ConstString &name);
297
305
 
298
306
    //------------------------------------------------------------------
299
307
    // Some plug-ins might register a DebuggerInitializeCallback