1#![allow(
4 dead_code,
5 non_camel_case_types,
6 non_upper_case_globals,
7 non_snake_case
8)]
9#![allow(clippy::unreadable_literal)]
10
11use bitflags::bitflags;
12use libc::FILE;
13
14pub type lldb_addr_t = u64;
16pub type lldb_break_id_t = i32;
18pub type lldb_watch_id_t = i32;
20pub type lldb_user_id_t = u64;
22pub type lldb_pid_t = u64;
24pub type lldb_queue_id_t = u64;
26pub type lldb_tid_t = u64;
28pub type lldb_offset_t = u64;
30pub enum SBAddressOpaque {}
31pub type SBAddressRef = *mut SBAddressOpaque;
32pub enum SBAttachInfoOpaque {}
33pub type SBAttachInfoRef = *mut SBAttachInfoOpaque;
34pub enum SBBlockOpaque {}
35pub type SBBlockRef = *mut SBBlockOpaque;
36pub enum SBBreakpointOpaque {}
37pub type SBBreakpointRef = *mut SBBreakpointOpaque;
38pub enum SBBreakpointListOpaque {}
39pub type SBBreakpointListRef = *mut SBBreakpointListOpaque;
40pub enum SBBreakpointLocationOpaque {}
41pub type SBBreakpointLocationRef = *mut SBBreakpointLocationOpaque;
42pub enum SBBreakpointNameOpaque {}
43pub type SBBreakpointNameRef = *mut SBBreakpointNameOpaque;
44pub enum SBBroadcasterOpaque {}
45pub type SBBroadcasterRef = *mut SBBroadcasterOpaque;
46pub enum SBCommandOpaque {}
47pub type SBCommandRef = *mut SBCommandOpaque;
48pub enum SBCommandInterpreterOpaque {}
49pub type SBCommandInterpreterRef = *mut SBCommandInterpreterOpaque;
50pub enum SBCommandInterpreterRunOptionsOpaque {}
51pub type SBCommandInterpreterRunOptionsRef = *mut SBCommandInterpreterRunOptionsOpaque;
52pub enum SBCommandPluginInterfaceOpaque {}
53pub type SBCommandPluginInterfaceRef = *mut SBCommandPluginInterfaceOpaque;
54pub enum SBCommandReturnObjectOpaque {}
55pub type SBCommandReturnObjectRef = *mut SBCommandReturnObjectOpaque;
56pub enum SBCommunicationOpaque {}
57pub type SBCommunicationRef = *mut SBCommunicationOpaque;
58pub enum SBCompileUnitOpaque {}
59pub type SBCompileUnitRef = *mut SBCompileUnitOpaque;
60pub enum SBDataOpaque {}
61pub type SBDataRef = *mut SBDataOpaque;
62pub enum SBDebuggerOpaque {}
63pub type SBDebuggerRef = *mut SBDebuggerOpaque;
64pub enum SBDeclarationOpaque {}
65pub type SBDeclarationRef = *mut SBDeclarationOpaque;
66pub enum SBEnvironmentOpaque {}
67pub type SBEnvironmentRef = *mut SBEnvironmentOpaque;
68pub enum SBErrorOpaque {}
69pub type SBErrorRef = *mut SBErrorOpaque;
70pub enum SBEventOpaque {}
71pub type SBEventRef = *mut SBEventOpaque;
72pub enum SBEventListOpaque {}
73pub type SBEventListRef = *mut SBEventListOpaque;
74pub enum SBExecutionContextOpaque {}
75pub type SBExecutionContextRef = *mut SBExecutionContextOpaque;
76pub enum SBExpressionOptionsOpaque {}
77pub type SBExpressionOptionsRef = *mut SBExpressionOptionsOpaque;
78pub enum SBFileOpaque {}
79pub type SBFileRef = *mut SBFileOpaque;
80pub enum SBFileSpecOpaque {}
81pub type SBFileSpecRef = *mut SBFileSpecOpaque;
82pub enum SBFileSpecListOpaque {}
83pub type SBFileSpecListRef = *mut SBFileSpecListOpaque;
84pub enum SBFrameOpaque {}
85pub type SBFrameRef = *mut SBFrameOpaque;
86pub enum SBFunctionOpaque {}
87pub type SBFunctionRef = *mut SBFunctionOpaque;
88pub enum SBHostOSOpaque {}
89pub type SBHostOSRef = *mut SBHostOSOpaque;
90pub enum SBInstructionOpaque {}
91pub type SBInstructionRef = *mut SBInstructionOpaque;
92pub enum SBInstructionListOpaque {}
93pub type SBInstructionListRef = *mut SBInstructionListOpaque;
94pub enum SBLaunchInfoOpaque {}
95pub type SBLaunchInfoRef = *mut SBLaunchInfoOpaque;
96pub enum SBLineEntryOpaque {}
97pub type SBLineEntryRef = *mut SBLineEntryOpaque;
98pub enum SBListenerOpaque {}
99pub type SBListenerRef = *mut SBListenerOpaque;
100pub enum SBMemoryRegionInfoOpaque {}
101pub type SBMemoryRegionInfoRef = *mut SBMemoryRegionInfoOpaque;
102pub enum SBMemoryRegionInfoListOpaque {}
103pub type SBMemoryRegionInfoListRef = *mut SBMemoryRegionInfoListOpaque;
104pub enum SBModuleOpaque {}
105pub type SBModuleRef = *mut SBModuleOpaque;
106pub enum SBModuleSpecOpaque {}
107pub type SBModuleSpecRef = *mut SBModuleSpecOpaque;
108pub enum SBModuleSpecListOpaque {}
109pub type SBModuleSpecListRef = *mut SBModuleSpecListOpaque;
110pub enum SBPlatformOpaque {}
111pub type SBPlatformRef = *mut SBPlatformOpaque;
112pub enum SBProcessOpaque {}
113pub type SBProcessRef = *mut SBProcessOpaque;
114pub enum SBProcessInfoOpaque {}
115pub type SBProcessInfoRef = *mut SBProcessInfoOpaque;
116pub enum SBQueueOpaque {}
117pub type SBQueueRef = *mut SBQueueOpaque;
118pub enum SBQueueItemOpaque {}
119pub type SBQueueItemRef = *mut SBQueueItemOpaque;
120pub enum SBSectionOpaque {}
121pub type SBSectionRef = *mut SBSectionOpaque;
122pub enum SBSourceManagerOpaque {}
123pub type SBSourceManagerRef = *mut SBSourceManagerOpaque;
124pub enum SBStreamOpaque {}
125pub type SBStreamRef = *mut SBStreamOpaque;
126pub enum SBStringListOpaque {}
127pub type SBStringListRef = *mut SBStringListOpaque;
128pub enum SBStructuredDataOpaque {}
129pub type SBStructuredDataRef = *mut SBStructuredDataOpaque;
130pub enum SBSymbolOpaque {}
131pub type SBSymbolRef = *mut SBSymbolOpaque;
132pub enum SBSymbolContextOpaque {}
133pub type SBSymbolContextRef = *mut SBSymbolContextOpaque;
134pub enum SBSymbolContextListOpaque {}
135pub type SBSymbolContextListRef = *mut SBSymbolContextListOpaque;
136pub enum SBTargetRefOpaque {}
137pub type SBTargetRef = *mut SBTargetRefOpaque;
138pub enum SBThreadRefOpaque {}
139pub type SBThreadRef = *mut SBThreadRefOpaque;
140pub enum SBThreadCollectionOpaque {}
141pub type SBThreadCollectionRef = *mut SBThreadCollectionOpaque;
142pub enum SBThreadPlanOpaque {}
143pub type SBThreadPlanRef = *mut SBThreadPlanOpaque;
144pub enum SBTypeOpaque {}
145pub type SBTypeRef = *mut SBTypeOpaque;
146pub enum SBTypeMemberOpaque {}
147pub type SBTypeMemberRef = *mut SBTypeMemberOpaque;
148pub enum SBTypeCategoryOpaque {}
149pub type SBTypeCategoryRef = *mut SBTypeCategoryOpaque;
150pub enum SBTypeEnumMemberOpaque {}
151pub type SBTypeEnumMemberRef = *mut SBTypeEnumMemberOpaque;
152pub enum SBTypeEnumMemberListOpaque {}
153pub type SBTypeEnumMemberListRef = *mut SBTypeEnumMemberListOpaque;
154pub enum SBTypeFilterOpaque {}
155pub type SBTypeFilterRef = *mut SBTypeFilterOpaque;
156pub enum SBTypeFormatOpaque {}
157pub type SBTypeFormatRef = *mut SBTypeFormatOpaque;
158pub enum SBTypeMemberFunctionOpaque {}
159pub type SBTypeMemberFunctionRef = *mut SBTypeMemberFunctionOpaque;
160pub enum SBTypeNameSpecifierOpaque {}
161pub type SBTypeNameSpecifierRef = *mut SBTypeNameSpecifierOpaque;
162pub enum SBTypeSummaryOpaque {}
163pub type SBTypeSummaryRef = *mut SBTypeSummaryOpaque;
164pub enum SBTypeSummaryOptionsOpaque {}
165pub type SBTypeSummaryOptionsRef = *mut SBTypeSummaryOptionsOpaque;
166pub enum SBInputReaderOpaque {}
167pub type SBInputReaderRef = *mut SBInputReaderOpaque;
168pub enum SBPlatformConnectOptionsOpaque {}
169pub type SBPlatformConnectOptionsRef = *mut SBPlatformConnectOptionsOpaque;
170pub enum SBPlatformShellCommandOpaque {}
171pub type SBPlatformShellCommandRef = *mut SBPlatformShellCommandOpaque;
172pub enum SBTypeSyntheticOpaque {}
173pub type SBTypeSyntheticRef = *mut SBTypeSyntheticOpaque;
174pub enum SBTypeListOpaque {}
175pub type SBTypeListRef = *mut SBTypeListOpaque;
176pub enum SBValueOpaque {}
177pub type SBValueRef = *mut SBValueOpaque;
178pub enum SBValueListOpaque {}
179pub type SBValueListRef = *mut SBValueListOpaque;
180pub enum SBVariablesOptionsOpaque {}
181pub type SBVariablesOptionsRef = *mut SBVariablesOptionsOpaque;
182pub enum SBWatchpointOpaque {}
183pub type SBWatchpointRef = *mut SBWatchpointOpaque;
184pub enum SBUnixSignalsOpaque {}
185pub type SBUnixSignalsRef = *mut SBUnixSignalsOpaque;
186#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
188#[repr(u32)]
189pub enum StateType {
190 Invalid = 0,
191 Unloaded = 1,
193 Connected = 2,
196 Attaching = 3,
198 Launching = 4,
200 Stopped = 5,
202 Running = 6,
204 Stepping = 7,
206 Crashed = 8,
208 Detached = 9,
210 Exited = 10,
212 Suspended = 11,
216}
217bitflags! {
218 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
219 #[repr(C)]
220 pub struct LaunchFlags: u32 {
221 const EXEC = 0b0000001;
223 const DEBUG = 0b0000010;
225 const STOP_AT_ENTRY = 0b0000100;
228 const DISABLE_ASLR = 8;
230 const DISABLE_STDIO = 16;
232 const LAUNCH_IN_TTY = 32;
234 const LAUNCH_IN_SHELL = 64;
236 const LAUNCH_IN_SEPARATE_PROCESS_GROUP = 128;
238 const DONT_SET_EXIT_STATUS = 256;
242 const DETACH_ON_ERROR = 512;
245 const SHELL_EXPAND_ARGUMENTS = 1024;
247 const CLOSE_TTY_ON_EXIT = 2048;
249 }
250}
251
252#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
254#[repr(u32)]
255pub enum RunMode {
256 OnlyThisThread = 0,
257 AllThreads = 1,
258 OnlyDuringStepping = 2,
259}
260
261#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
263#[repr(u32)]
264pub enum ByteOrder {
265 Invalid = 0,
266 Big = 1,
267 PDP = 2,
268 Little = 4,
269}
270
271#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
273#[repr(u32)]
274pub enum Encoding {
275 Invalid = 0,
276 Uint = 1,
278 Sint = 2,
280 IEEE754 = 3,
282 Vector = 4,
284}
285
286#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
288#[repr(u32)]
289pub enum Format {
290 Default = 0,
291 Boolean = 1,
292 Binary = 2,
293 Bytes = 3,
294 BytesWithASCII = 4,
295 Char = 5,
296 CharPrintable = 6,
297 Complex = 7,
298 CString = 8,
299 Decimal = 9,
300 Enum = 10,
301 Hex = 11,
302 HexUppercase = 12,
303 Float = 13,
304 Octal = 14,
305 OSType = 15,
306 Unicode16 = 16,
307 Unicode32 = 17,
308 Unsigned = 18,
309 Pointer = 19,
310 VectorOfChar = 20,
311 VectorOfSInt8 = 21,
312 VectorOfUInt8 = 22,
313 VectorOfSInt16 = 23,
314 VectorOfUInt16 = 24,
315 VectorOfSInt32 = 25,
316 VectorOfUInt32 = 26,
317 VectorOfSInt64 = 27,
318 VectorOfUInt64 = 28,
319 VectorOfFloat16 = 29,
320 VectorOfFloat32 = 30,
321 VectorOfFloat64 = 31,
322 VectorOfUInt128 = 32,
323 ComplexInteger = 33,
324 CharArray = 34,
325 AddressInfo = 35,
326 HexFloat = 36,
327 Instruction = 37,
328 Void = 38,
329 Unicode8 = 39,
330 kNumFormats = 40,
331}
332#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
333#[repr(u32)]
334pub enum DescriptionLevel {
335 Brief = 0,
336 Full = 1,
337 Verbose = 2,
338 Initial = 3,
339 kNumDescriptionLevels = 4,
340}
341#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
342#[repr(u32)]
343pub enum ScriptLanguage {
344 None = 0,
345 Python = 1,
346 Lua = 2,
347 Unknown = 3,
348}
349#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
350#[repr(u32)]
351pub enum RegisterKind {
352 EHFrame = 0,
353 DWARF = 1,
354 Generic = 2,
355 ProcessPlugin = 3,
356 LLDB = 4,
357 kNumRegisterKinds = 5,
358}
359
360#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
362#[repr(u32)]
363pub enum StopReason {
364 Invalid = 0,
365 None = 1,
366 Trace = 2,
367 Breakpoint = 3,
368 Watchpoint = 4,
369 Signal = 5,
370 Exception = 6,
371 Exec = 7,
372 PlanComplete = 8,
373 ThreadExiting = 9,
374 Instrumentation = 10,
375 ProcessorTrace = 11,
376 Fork = 12,
377 VFork = 13,
378 VForkDone = 14,
379}
380#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
381#[repr(u32)]
382pub enum ReturnStatus {
383 Invalid = 0,
384 SuccessFinishNoResult = 1,
385 SuccessFinishResult = 2,
386 SuccessContinuingNoResult = 3,
387 SuccessContinuingResult = 4,
388 Started = 5,
389 Failed = 6,
390 Quit = 7,
391}
392#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
393#[repr(u32)]
394pub enum ExpressionResults {
395 Completed = 0,
396 SetupError = 1,
397 ParseError = 2,
398 Discarded = 3,
399 Interrupted = 4,
400 HitBreakpoint = 5,
401 TimedOut = 6,
402 ResultUnavailable = 7,
403 StoppedForDebug = 8,
404 ThreadVanished = 9,
405}
406#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
407#[repr(u32)]
408pub enum ConnectionStatus {
409 ConnectionStatusSuccess = 0,
410 ConnectionStatusEndOfFile = 1,
411 ConnectionStatusError = 2,
412 ConnectionStatusTimedOut = 3,
413 ConnectionStatusNoConnection = 4,
414 ConnectionStatusLostConnection = 5,
415 ConnectionStatusInterrupted = 6,
416}
417#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
418#[repr(u32)]
419pub enum ErrorType {
420 Invalid = 0,
421 Generic = 1,
422 MachKernel = 2,
423 POSIX = 3,
424 Expression = 4,
425 Win32 = 5,
426}
427#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
428#[repr(u32)]
429pub enum ValueType {
430 Invalid = 0,
431 VariableGlobal = 1,
432 VariableStatic = 2,
433 VariableArgument = 3,
434 VariableLocal = 4,
435 Register = 5,
436 RegisterSet = 6,
437 ConstResult = 7,
438 VariableThreadLocal = 8,
439}
440#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
441#[repr(u32)]
442pub enum InputReaderGranularity {
443 Invalid = 0,
444 Byte = 1,
445 Word = 2,
446 Line = 3,
447 All = 4,
448}
449
450bitflags! {
451 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
460 #[repr(C)]
461 pub struct SymbolContextItem: u32 {
462 const TARGET = 1;
465 const MODULE = 2;
468 const COMPUNIT = 4;
471 const FUNCTION = 8;
474 const BLOCK = 16;
477 const LINE_ENTRY = 32;
480 const SYMBOL = 64;
483 const EVERYTHING
486 = Self::TARGET.bits() |
487 Self::MODULE.bits() |
488 Self::COMPUNIT.bits() |
489 Self::FUNCTION.bits() |
490 Self::BLOCK.bits() |
491 Self::LINE_ENTRY.bits() |
492 Self::SYMBOL.bits();
493 const VARIABLE = 128;
500 }
501}
502bitflags! {
503 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
504 #[repr(C)]
505 pub struct Permissions: u32 {
506 const WRITABLE = 1;
507 const READABLE = 2;
508 const EXECUTABLE = 4;
509 }
510}
511#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
512#[repr(u32)]
513pub enum InputReaderAction {
514 Activate = 0,
515 AsynchronousOutputWritten = 1,
516 Reactivate = 2,
517 Deactivate = 3,
518 GotToken = 4,
519 Interrupt = 5,
520 EndOfFile = 6,
521 Done = 7,
522}
523#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
524#[repr(u32)]
525pub enum BreakpointEventType {
526 InvalidType = 1,
527 Added = 2,
528 Removed = 4,
529 LocationsAdded = 8,
530 LocationsRemoved = 16,
531 LocationsResolved = 32,
532 Enabled = 64,
533 Disabled = 128,
534 CommandChanged = 256,
535 ConditionChanged = 512,
536 IgnoreChanged = 1024,
537 ThreadChanged = 2048,
538 AutoContinueChanged = 4096,
539}
540#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
541#[repr(u32)]
542pub enum WatchpointEventType {
543 InvalidType = 1,
544 Added = 2,
545 Removed = 4,
546 Enabled = 64,
547 Disabled = 128,
548 CommandChanged = 256,
549 ConditionChanged = 512,
550 IgnoreChanged = 1024,
551 ThreadChanged = 2048,
552 TypeChanged = 4096,
553}
554#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
555#[repr(u32)]
556pub enum LanguageType {
557 Unknown = 0,
558 C89 = 1,
559 C = 2,
560 Ada83 = 3,
561 C_plus_plus = 4,
562 Cobol74 = 5,
563 Cobol85 = 6,
564 Fortran77 = 7,
565 Fortran90 = 8,
566 Pascal83 = 9,
567 Modula2 = 10,
568 Java = 11,
569 C99 = 12,
570 Ada95 = 13,
571 Fortran95 = 14,
572 PLI = 15,
573 ObjC = 16,
574 ObjC_plus_plus = 17,
575 UPC = 18,
576 D = 19,
577 Python = 20,
578 OpenCL = 21,
579 Go = 22,
580 Modula3 = 23,
581 Haskell = 24,
582 C_plus_plus_03 = 25,
583 C_plus_plus_11 = 26,
584 OCaml = 27,
585 Rust = 28,
586 C11 = 29,
587 Swift = 30,
588 Julia = 31,
589 Dylan = 32,
590 C_plus_plus_14 = 33,
591 Fortran03 = 34,
592 Fortran08 = 35,
593 MipsAssembler = 36,
594 ExtRenderScript = 37,
595 NumLanguageTypes = 38,
596}
597#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
598#[repr(u32)]
599pub enum InstrumentationRuntimeType {
600 AddressSanitizer = 0,
601 ThreadSanitizer = 1,
602 UndefinedBehaviorSanitizer = 2,
603 MainThreadChecker = 3,
604 SwiftRuntimeReporting = 4,
605 NumInstrumentationRuntimeTypes = 5,
606}
607#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
608#[repr(u32)]
609pub enum DynamicValueType {
610 NoDynamicValues = 0,
611 DynamicCanRunTarget = 1,
612 DynamicDontRunTarget = 2,
613}
614#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
615#[repr(u32)]
616pub enum AccessType {
617 None = 0,
618 Public = 1,
619 Private = 2,
620 Protected = 3,
621 Package = 4,
622}
623#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
624#[repr(u32)]
625pub enum CommandArgumentType {
626 Address = 0,
627 AddressOrExpression = 1,
628 AliasName = 2,
629 AliasOptions = 3,
630 Architecture = 4,
631 Boolean = 5,
632 BreakpointID = 6,
633 BreakpointIDRange = 7,
634 BreakpointName = 8,
635 ByteSize = 9,
636 ClassName = 10,
637 CommandName = 11,
638 Count = 12,
639 DescriptionVerbosity = 13,
640 DirectoryName = 14,
641 DisassemblyFlavor = 15,
642 EndAddress = 16,
643 Expression = 17,
644 ExpressionPath = 18,
645 ExprFormat = 19,
646 Filename = 20,
647 Format = 21,
648 FrameIndex = 22,
649 FullName = 23,
650 FunctionName = 24,
651 FunctionOrSymbol = 25,
652 GDBFormat = 26,
653 HelpText = 27,
654 Index = 28,
655 Language = 29,
656 LineNum = 30,
657 LogCategory = 31,
658 LogChannel = 32,
659 Method = 33,
660 Name = 34,
661 NewPathPrefix = 35,
662 NumLines = 36,
663 NumberPerLine = 37,
664 Offset = 38,
665 OldPathPrefix = 39,
666 OneLiner = 40,
667 Path = 41,
668 PermissionsNumber = 42,
669 PermissionsString = 43,
670 Pid = 44,
671 Plugin = 45,
672 ProcessName = 46,
673 PythonClass = 47,
674 PythonFunction = 48,
675 PythonScript = 49,
676 QueueName = 50,
677 RegisterName = 51,
678 RegularExpression = 52,
679 RunArgs = 53,
680 RunMode = 54,
681 ScriptedCommandSynchronicity = 55,
682 ScriptLang = 56,
683 SearchWord = 57,
684 Selector = 58,
685 SettingIndex = 59,
686 SettingKey = 60,
687 SettingPrefix = 61,
688 SettingVariableName = 62,
689 ShlibName = 63,
690 SourceFile = 64,
691 SortOrder = 65,
692 StartAddress = 66,
693 SummaryString = 67,
694 Symbol = 68,
695 ThreadID = 69,
696 ThreadIndex = 70,
697 ThreadName = 71,
698 TypeName = 72,
699 UnsignedInteger = 73,
700 UnixSignal = 74,
701 VarName = 75,
702 Value = 76,
703 Width = 77,
704 None = 78,
705 Platform = 79,
706 WatchpointID = 80,
707 WatchpointIDRange = 81,
708 WatchType = 82,
709 RawInput = 83,
710 Command = 84,
711 ColumnNum = 85,
712 LastArg = 86,
713 ModuleUUID = 87,
714 SaveCoreStyle = 88,
715 LogHandler = 89,
716 SEDStylePair = 90,
717 RecognizerID = 91,
718 ConnectURL = 92,
719 TargetID = 93,
720 StopHookID = 94,
721 ReproducerProvider = 95,
722 ReproducerSignal = 96,
723}
724#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
725#[repr(u32)]
726pub enum SymbolType {
727 Any = 0,
728 Absolute = 1,
729 Code = 2,
730 Resolver = 3,
731 Data = 4,
732 Trampoline = 5,
733 Runtime = 6,
734 Exception = 7,
735 SourceFile = 8,
736 HeaderFile = 9,
737 ObjectFile = 10,
738 CommonBlock = 11,
739 Block = 12,
740 Local = 13,
741 Param = 14,
742 Variable = 15,
743 VariableType = 16,
744 LineEntry = 17,
745 LineHeader = 18,
746 ScopeBegin = 19,
747 ScopeEnd = 20,
748 Additional = 21,
749 Compiler = 22,
750 Instrumentation = 23,
751 Undefined = 24,
752 ObjCClass = 25,
753 ObjCMetaClass = 26,
754 ObjCIVar = 27,
755 ReExported = 28,
756}
757#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
758#[repr(u32)]
759pub enum SectionType {
760 Invalid = 0,
761 Code = 1,
762 Container = 2,
764 Data = 3,
765 DataCString = 4,
767 DataCStringPointers = 5,
769 DataSymbolAddress = 6,
771 Data4 = 7,
772 Data8 = 8,
773 Data16 = 9,
774 DataPointers = 10,
775 Debug = 11,
776 ZeroFill = 12,
777 DataObjCMessageRefs = 13,
779 DataObjCCFStrings = 14,
781 DWARFDebugAbbrev = 15,
782 DWARFDebugAddr = 16,
783 DWARFDebugAranges = 17,
784 DWARFDebugFrame = 18,
785 DWARFDebugInfo = 19,
786 DWARFDebugLine = 20,
787 DWARFDebugLoc = 21,
788 DWARFDebugMacInfo = 22,
789 DWARFDebugMacro = 23,
790 DWARFDebugPubNames = 24,
791 DWARFDebugPubTypes = 25,
792 DWARFDebugRanges = 26,
793 DWARFDebugStr = 27,
794 DWARFDebugStrOffsets = 28,
795 DWARFAppleNames = 29,
796 DWARFAppleTypes = 30,
797 DWARFAppleNamespaces = 31,
798 DWARFAppleObjC = 32,
799 ELFSymbolTable = 33,
801 ELFDynamicSymbols = 34,
803 ELFRelocationEntries = 35,
805 ELFDynamicLinkInfo = 36,
807 EHFrame = 37,
808 ARMexidx = 38,
809 ARMextab = 39,
810 CompactUnwind = 40,
812 GoSymtab = 41,
813 AbsoluteAddress = 42,
815 DWARFGNUDebugAltLink = 43,
816 DWARFDebugTypes = 44,
818 DWARFDebugNames = 45,
820 Other = 46,
821 DWARFDebugLineStr = 47,
823 DWARFDebugRngLists = 48,
825 DWARFDebugLocLists = 49,
827 DWARFDebugAbbrevDwo = 50,
828 DWARFDebugInfoDwo = 51,
829 DWARFDebugStrDwo = 52,
830 DWARFDebugStrOffsetsDwo = 53,
831 DWARFDebugTypesDwo = 54,
832 DWARFDebugRngListsDwo = 55,
833 DWARFDebugLocDwo = 56,
834 DWARFDebugLocListsDwo = 57,
835 DWARFDebugTuIndex = 58,
836}
837bitflags! {
838 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
839 #[repr(C)]
840 pub struct EmulateInstructionOptions: u32 {
841 const NONE = 0;
842 const AUTO_ADVANCE_PC = 1;
843 const IGNORE_CONDITIONS = 2;
844 }
845}
846bitflags! {
847 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
848 #[repr(C)]
849 pub struct FunctionNameType: u32 {
850 const NONE = 0;
851 const AUTO = 2;
852 const FULL = 4;
853 const BASE = 8;
854 const METHOD = 16;
855 const SELECTOR = 32;
856 }
857}
858#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
859#[repr(u32)]
860pub enum BasicType {
861 Invalid = 0,
862 Void = 1,
863 Char = 2,
864 SignedChar = 3,
865 UnsignedChar = 4,
866 WChar = 5,
867 SignedWChar = 6,
868 UnsignedWChar = 7,
869 Char16 = 8,
870 Char32 = 9,
871 Short = 10,
872 UnsignedShort = 11,
873 Int = 12,
874 UnsignedInt = 13,
875 Long = 14,
876 UnsignedLong = 15,
877 LongLong = 16,
878 UnsignedLongLong = 17,
879 Int128 = 18,
880 UnsignedInt128 = 19,
881 Bool = 20,
882 Half = 21,
883 Float = 22,
884 Double = 23,
885 LongDouble = 24,
886 FloatComplex = 25,
887 DoubleComplex = 26,
888 LongDoubleComplex = 27,
889 ObjCID = 28,
890 ObjCClass = 29,
891 ObjCSel = 30,
892 NullPtr = 31,
893 Other = 32,
894}
895
896#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
897#[repr(i32)]
898pub enum StructuredDataType {
899 Invalid = -1,
900 Null = 0,
901 Generic,
902 Array,
903 Integer,
904 Float,
905 Boolean,
906 String,
907 Dictionary,
908}
909
910bitflags! {
911 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
912 #[repr(C)]
913 pub struct TypeClass: u32 {
914 const INVALID = 0;
915 const ARRAY = 1;
916 const BLOCKPOINTER = 2;
917 const BUILTIN = 4;
918 const CLASS = 8;
919 const COMPLEX_FLOAT = 16;
920 const COMPLEX_INTEGER = 32;
921 const ENUMERATION = 64;
922 const FUNCTION = 128;
923 const MEMBER_POINTER = 256;
924 const OBJC_OBJECT = 512;
925 const OBJC_INTERFACE = 1024;
926 const OBJC_OBJECT_POINTER = 2048;
927 const POINTER = 4096;
928 const REFERENCE = 8192;
929 const STRUCT = 16384;
930 const TYPEDEF = 32768;
931 const UNION = 65536;
932 const VECTOR = 131072;
933 const OTHER = 2147483648;
934 const ANY = 4294967295;
935 }
936}
937#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
938#[repr(u32)]
939pub enum TemplateArgumentKind {
940 Null = 0,
941 Type = 1,
942 Declaration = 2,
943 Integral = 3,
944 Template = 4,
945 TemplateExpansion = 5,
946 Expression = 6,
947 Pack = 7,
948 NullPtr = 8,
949}
950bitflags! {
951 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
952 #[repr(C)]
953 pub struct TypeOptions: u32 {
954 const NONE = 0;
955 const CASCADE = 1;
956 const SKIP_POINTERS = 2;
957 const SKIP_REFERENCES = 4;
958 const HIDE_CHILDREN = 8;
959 const HIDE_VALUE = 16;
960 const SHOW_ONE_LINER = 32;
961 const HIDE_NAMES = 64;
962 const NONCACHEABLE = 128;
963 const HIDE_EMPTY_AGGREGATES = 256;
964 const FRONT_END_WANTS_DEREFERENCE = 512;
965 }
966}
967#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
968#[repr(u32)]
969pub enum FrameComparison {
970 Invalid = 0,
971 Unknown = 1,
972 Equal = 2,
973 SameParent = 3,
974 Younger = 4,
975 Older = 5,
976}
977bitflags! {
978 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
979 #[repr(C)]
980 pub struct FilePermissions: u32 {
981 const WORLD_EXECUTE = 1;
982 const WORLD_WRITE = 2;
983 const WORLD_READ = 4;
984 const GROUP_EXECUTE = 8;
985 const GROUP_WRITE = 16;
986 const GROUP_READ = 32;
987 const USER_EXECUTE = 64;
988 const USER_WRITE = 128;
989 const USER_READ = 256;
990 const WORLD_RX
991 = Self::WORLD_READ.bits() |
992 Self::WORLD_EXECUTE.bits();
993 const WORLD_RW
994 = Self::WORLD_READ.bits() |
995 Self::WORLD_WRITE.bits();
996 const WORLD_RWX
997 = Self::WORLD_READ.bits() |
998 Self::WORLD_WRITE.bits() |
999 Self::WORLD_EXECUTE.bits();
1000 const GROUP_RX
1001 = Self::GROUP_READ.bits() |
1002 Self::GROUP_EXECUTE.bits();
1003 const GROUP_RW
1004 = Self::GROUP_READ.bits() |
1005 Self::GROUP_WRITE.bits();
1006 const GROUP_RWX
1007 = Self::GROUP_READ.bits() |
1008 Self::GROUP_WRITE.bits() |
1009 Self::GROUP_EXECUTE.bits();
1010 const USER_RX
1011 = Self::USER_READ.bits() |
1012 Self::USER_EXECUTE.bits();
1013 const USER_RW
1014 = Self::USER_READ.bits() |
1015 Self::USER_WRITE.bits();
1016 const USER_RWX
1017 = Self::USER_READ.bits() |
1018 Self::USER_WRITE.bits() |
1019 Self::USER_EXECUTE.bits();
1020 const EVERYONE_R
1021 = Self::WORLD_READ.bits() |
1022 Self::GROUP_READ.bits() |
1023 Self::USER_READ.bits();
1024 const EVERYONE_W
1025 = Self::WORLD_WRITE.bits() |
1026 Self::GROUP_WRITE.bits() |
1027 Self::USER_WRITE.bits();
1028 const EVERYONE_X
1029 = Self::WORLD_EXECUTE.bits() |
1030 Self::GROUP_EXECUTE.bits() |
1031 Self::USER_EXECUTE.bits();
1032 const EVERYONE_RW
1033 = Self::EVERYONE_R.bits() |
1034 Self::EVERYONE_W.bits();
1035 const EVERYONE_RX
1036 = Self::EVERYONE_R.bits() |
1037 Self::EVERYONE_X.bits();
1038 const EVERYONE_RWX
1039 = Self::EVERYONE_R.bits() |
1040 Self::EVERYONE_W.bits() |
1041 Self::EVERYONE_X.bits();
1042 const FILE_DEFAULT
1043 = Self::USER_RW.bits();
1044 const DIRECTORY_DEFAULT
1045 = Self::USER_RWX.bits();
1046 }
1047}
1048#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
1049#[repr(u32)]
1050pub enum QueueItemKind {
1051 Unknown = 0,
1052 Function = 1,
1053 Block = 2,
1054}
1055#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
1056#[repr(u32)]
1057pub enum QueueKind {
1058 Unknown = 0,
1059 Serial = 1,
1060 Concurrent = 2,
1061}
1062#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
1063#[repr(u32)]
1064pub enum ExpressionEvaluationPhase {
1065 EvaluationParse = 0,
1066 EvaluationIRGen = 1,
1067 EvaluationExecution = 2,
1068 EvaluationComplete = 3,
1069}
1070bitflags! {
1071 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1072 #[repr(C)]
1073 pub struct WatchpointKind: u32 {
1074 const READ = 1;
1075 const WRITE = 2;
1076 }
1077}
1078#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
1079#[repr(u32)]
1080pub enum GdbSignal {
1081 BadAccess = 145,
1082 BadInstruction = 146,
1083 Arithmetic = 147,
1084 Emulation = 148,
1085 Software = 149,
1086 Breakpoint = 150,
1087}
1088#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
1089#[repr(u32)]
1090pub enum PathType {
1091 LLDBShlibDir = 0,
1092 SupportExecutableDir = 1,
1093 HeaderDir = 2,
1094 PythonDir = 3,
1095 LLDBSystemPlugins = 4,
1096 LLDBUserPlugins = 5,
1097 LLDBTempSystemDir = 6,
1098 GlobalLLDBTempSystemDir = 7,
1099 ClangDir = 8,
1100}
1101#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
1102#[repr(u32)]
1103pub enum MemberFunctionKind {
1104 Unknown = 0,
1105 Constructor = 1,
1106 Destructor = 2,
1107 InstanceMethod = 3,
1108 StaticMethod = 4,
1109}
1110#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
1111#[repr(u32)]
1112pub enum MatchType {
1113 Normal = 0,
1114 Regex = 1,
1115 StartsWith = 2,
1116}
1117bitflags! {
1118 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1119 #[repr(C)]
1120 pub struct TypeFlags: u32 {
1121 const HAS_CHILDREN = 1;
1122 const HAS_VALUE = 2;
1123 const IS_ARRAY = 4;
1124 const IS_BLOCK = 8;
1125 const IS_BUILTIN = 16;
1126 const IS_CLASS = 32;
1127 const IS_CPLUSPLUS = 64;
1128 const IS_ENUMERATION = 128;
1129 const IS_FUNC_PROTOTYPE = 256;
1130 const IS_MEMBER = 512;
1131 const IS_OBJC = 1024;
1132 const IS_POINTER = 2048;
1133 const IS_REFERENCE = 4096;
1134 const IS_STRUCT_UNION = 8192;
1135 const IS_TEMPLATE = 16384;
1136 const IS_TYPEDEF = 32768;
1137 const IS_VECTOR = 65536;
1138 const IS_SCALAR = 131072;
1139 const IS_INTEGER = 262144;
1140 const IS_FLOAT = 524288;
1141 const IS_COMPLEX = 1048576;
1142 const IS_SIGNED = 2097152;
1143 const INSTANCE_IS_POINTER = 4194304;
1144 }
1145}
1146bitflags! {
1147 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1148 #[repr(C)]
1149 pub struct CommandFlags: u32 {
1150 const REQUIRES_TARGET = 1;
1151 const REQUIRES_PROCESS = 2;
1152 const REQUIRES_THREAD = 4;
1153 const REQUIRES_FRAME = 8;
1154 const REQUIRES_REG_CONTEXT = 16;
1155 const TRY_TARGET_API_LOCK = 32;
1156 const PROCESS_MUST_BE_LAUNCHED = 64;
1157 const PROCESS_MUST_BE_PAUSED = 128;
1158 const PROCESS_MUST_BE_TRACED = 256;
1159 }
1160}
1161#[derive(Copy, Clone, Debug, Eq, PartialEq, PartialOrd)]
1162#[repr(u32)]
1163pub enum TypeSummaryCapping {
1164 SummaryCapped = 1,
1165 SummaryUncapped = 0,
1166}
1167pub type ReadThreadBytesReceived = ::std::option::Option<
1168 unsafe extern "C" fn(
1169 baton: *mut ::std::os::raw::c_void,
1170 src: *const ::std::os::raw::c_void,
1171 src_len: usize,
1172 ),
1173>;
1174pub type SBBreakpointHitCallback = unsafe extern "C" fn(
1175 baton: *mut ::std::os::raw::c_void,
1176 process: SBProcessRef,
1177 thread: SBThreadRef,
1178 location: SBBreakpointLocationRef,
1179);
1180extern "C" {
1181 pub fn CreateSBAddress() -> SBAddressRef;
1182 pub fn CreateSBAddress2(section: SBSectionRef, offset: lldb_addr_t) -> SBAddressRef;
1183 pub fn CreateSBAddress3(load_addr: lldb_addr_t, target: SBTargetRef) -> SBAddressRef;
1184 pub fn CloneSBAddress(instance: SBAddressRef) -> SBAddressRef;
1185 pub fn DisposeSBAddress(instance: SBAddressRef);
1186 pub fn SBAddressIsValid(instance: SBAddressRef) -> bool;
1187 pub fn SBAddressClear(instance: SBAddressRef);
1188 pub fn SBAddressGetFileAddress(instance: SBAddressRef) -> lldb_addr_t;
1189 pub fn SBAddressGetLoadAddress(instance: SBAddressRef, target: SBTargetRef) -> lldb_addr_t;
1190 pub fn SBAddressSetAddress(instance: SBAddressRef, section: SBSectionRef, offset: lldb_addr_t);
1191 pub fn SBAddressSetLoadAddress(
1192 instance: SBAddressRef,
1193 load_addr: lldb_addr_t,
1194 target: SBTargetRef,
1195 );
1196 pub fn SBAddressOffsetAddress(instance: SBAddressRef, offset: lldb_addr_t) -> bool;
1197 pub fn SBAddressGetDescription(instance: SBAddressRef, description: SBStreamRef) -> bool;
1198 pub fn SBAddressGetSymbolContext(
1199 instance: SBAddressRef,
1200 resolve_scope: u32,
1201 ) -> SBSymbolContextRef;
1202 pub fn SBAddressGetSection(instance: SBAddressRef) -> SBSectionRef;
1203 pub fn SBAddressGetOffset(instance: SBAddressRef) -> lldb_addr_t;
1204 pub fn SBAddressGetModule(instance: SBAddressRef) -> SBModuleRef;
1205 pub fn SBAddressGetCompileUnit(instance: SBAddressRef) -> SBCompileUnitRef;
1206 pub fn SBAddressGetFunction(instance: SBAddressRef) -> SBFunctionRef;
1207 pub fn SBAddressGetBlock(instance: SBAddressRef) -> SBBlockRef;
1208 pub fn SBAddressGetSymbol(instance: SBAddressRef) -> SBSymbolRef;
1209 pub fn SBAddressGetLineEntry(instance: SBAddressRef) -> SBLineEntryRef;
1210 pub fn SBAddressIsEqual(instance: SBAddressRef, other: SBAddressRef) -> bool;
1211 pub fn CreateSBAttachInfo() -> SBAttachInfoRef;
1212 pub fn CreateSBAttachInfo2(pid: lldb_pid_t) -> SBAttachInfoRef;
1213 pub fn CreateSBAttachInfo3(
1214 path: *const ::std::os::raw::c_char,
1215 wait_for: bool,
1216 ) -> SBAttachInfoRef;
1217 pub fn CreateSBAttachInfo4(
1218 path: *const ::std::os::raw::c_char,
1219 wait_for: bool,
1220 asynchronous: bool,
1221 ) -> SBAttachInfoRef;
1222 pub fn CloneSBAttachInfo(instance: SBAttachInfoRef) -> SBAttachInfoRef;
1223 pub fn DisposeSBAttachInfo(instance: SBAttachInfoRef);
1224 pub fn SBAttachInfoGetProcessID(instance: SBAttachInfoRef) -> lldb_pid_t;
1225 pub fn SBAttachInfoSetProcessID(instance: SBAttachInfoRef, pid: lldb_pid_t);
1226 pub fn SBAttachInfoSetExecutable(
1227 instance: SBAttachInfoRef,
1228 path: *const ::std::os::raw::c_char,
1229 );
1230 pub fn SBAttachInfoSetExecutable2(instance: SBAttachInfoRef, exe_file: SBFileSpecRef);
1231 pub fn SBAttachInfoGetWaitForLaunch(instance: SBAttachInfoRef) -> bool;
1232 pub fn SBAttachInfoSetWaitForLaunch(instance: SBAttachInfoRef, b: bool);
1233 pub fn SBAttachInfoSetWaitForLaunch2(instance: SBAttachInfoRef, b: bool, asynchronous: bool);
1234 pub fn SBAttachInfoGetIgnoreExisting(instance: SBAttachInfoRef) -> bool;
1235 pub fn SBAttachInfoSetIgnoreExisting(instance: SBAttachInfoRef, b: bool);
1236 pub fn SBAttachInfoGetResumeCount(instance: SBAttachInfoRef) -> u32;
1237 pub fn SBAttachInfoSetResumeCount(instance: SBAttachInfoRef, c: u32);
1238 pub fn SBAttachInfoGetProcessPluginName(
1239 instance: SBAttachInfoRef,
1240 ) -> *const ::std::os::raw::c_char;
1241 pub fn SBAttachInfoSetProcessPluginName(
1242 instance: SBAttachInfoRef,
1243 plugin_name: *const ::std::os::raw::c_char,
1244 );
1245 pub fn SBAttachInfoGetUserID(instance: SBAttachInfoRef) -> u32;
1246 pub fn SBAttachInfoGetGroupID(instance: SBAttachInfoRef) -> u32;
1247 pub fn SBAttachInfoUserIDIsValid(instance: SBAttachInfoRef) -> bool;
1248 pub fn SBAttachInfoGroupIDIsValid(instance: SBAttachInfoRef) -> bool;
1249 pub fn SBAttachInfoSetUserID(instance: SBAttachInfoRef, uid: u32);
1250 pub fn SBAttachInfoSetGroupID(instance: SBAttachInfoRef, gid: u32);
1251 pub fn SBAttachInfoGetEffectiveUserID(instance: SBAttachInfoRef) -> u32;
1252 pub fn SBAttachInfoGetEffectiveGroupID(instance: SBAttachInfoRef) -> u32;
1253 pub fn SBAttachInfoEffectiveUserIDIsValid(instance: SBAttachInfoRef) -> bool;
1254 pub fn SBAttachInfoEffectiveGroupIDIsValid(instance: SBAttachInfoRef) -> bool;
1255 pub fn SBAttachInfoSetEffectiveUserID(instance: SBAttachInfoRef, uid: u32);
1256 pub fn SBAttachInfoSetEffectiveGroupID(instance: SBAttachInfoRef, gid: u32);
1257 pub fn SBAttachInfoGetParentProcessID(instance: SBAttachInfoRef) -> lldb_pid_t;
1258 pub fn SBAttachInfoSetParentProcessID(instance: SBAttachInfoRef, pid: lldb_pid_t);
1259 pub fn SBAttachInfoParentProcessIDIsValid(instance: SBAttachInfoRef) -> bool;
1260 pub fn SBAttachInfoGetListener(instance: SBAttachInfoRef) -> SBListenerRef;
1261 pub fn SBAttachInfoSetListener(instance: SBAttachInfoRef, listener: SBListenerRef);
1262 pub fn CreateSBBlock() -> SBBlockRef;
1263 pub fn CloneSBBlock(instance: SBBlockRef) -> SBBlockRef;
1264 pub fn DisposeSBBlock(instance: SBBlockRef);
1265 pub fn SBBlockIsInlined(instance: SBBlockRef) -> bool;
1266 pub fn SBBlockIsValid(instance: SBBlockRef) -> bool;
1267 pub fn SBBlockGetInlinedName(instance: SBBlockRef) -> *const ::std::os::raw::c_char;
1268 pub fn SBBlockGetInlinedCallSiteFile(instance: SBBlockRef) -> SBFileSpecRef;
1269 pub fn SBBlockGetInlinedCallSiteLine(instance: SBBlockRef) -> u32;
1270 pub fn SBBlockGetInlinedCallSiteColumn(instance: SBBlockRef) -> u32;
1271 pub fn SBBlockGetParent(instance: SBBlockRef) -> SBBlockRef;
1272 pub fn SBBlockGetSibling(instance: SBBlockRef) -> SBBlockRef;
1273 pub fn SBBlockGetFirstChild(instance: SBBlockRef) -> SBBlockRef;
1274 pub fn SBBlockGetNumRanges(instance: SBBlockRef) -> u32;
1275 pub fn SBBlockGetRangeStartAddress(instance: SBBlockRef, idx: u32) -> SBAddressRef;
1276 pub fn SBBlockGetRangeEndAddress(instance: SBBlockRef, idx: u32) -> SBAddressRef;
1277 pub fn SBBlockGetRangeIndexForBlockAddress(
1278 instance: SBBlockRef,
1279 block_addr: SBAddressRef,
1280 ) -> u32;
1281 pub fn SBBlockGetVariables(
1282 instance: SBBlockRef,
1283 frame: SBFrameRef,
1284 arguments: bool,
1285 locals: bool,
1286 statics: bool,
1287 use_dynamic: DynamicValueType,
1288 ) -> SBValueListRef;
1289 pub fn SBBlockGetVariables2(
1290 instance: SBBlockRef,
1291 target: SBTargetRef,
1292 arguments: bool,
1293 locals: bool,
1294 statics: bool,
1295 ) -> SBValueListRef;
1296 pub fn SBBlockGetContainingInlinedBlock(instance: SBBlockRef) -> SBBlockRef;
1297 pub fn SBBlockGetDescription(instance: SBBlockRef, description: SBStreamRef) -> bool;
1298 pub fn CreateSBBreakpoint() -> SBBreakpointRef;
1299 pub fn CloneSBBreakpoint(instance: SBBreakpointRef) -> SBBreakpointRef;
1300 pub fn DisposeSBBreakpoint(instance: SBBreakpointRef);
1301 pub fn SBBreakpointGetID(instance: SBBreakpointRef) -> lldb_break_id_t;
1302 pub fn SBBreakpointIsValid(instance: SBBreakpointRef) -> bool;
1303 pub fn SBBreakpointClearAllBreakpointSites(instance: SBBreakpointRef);
1304 pub fn SBBreakpointGetTarget(instance: SBBreakpointRef) -> SBTargetRef;
1305 pub fn SBBreakpointFindLocationByAddress(
1306 instance: SBBreakpointRef,
1307 vm_addr: lldb_addr_t,
1308 ) -> SBBreakpointLocationRef;
1309 pub fn SBBreakpointFindLocationIDByAddress(
1310 instance: SBBreakpointRef,
1311 vm_addr: lldb_addr_t,
1312 ) -> lldb_break_id_t;
1313 pub fn SBBreakpointFindLocationByID(
1314 instance: SBBreakpointRef,
1315 bp_loc_id: lldb_break_id_t,
1316 ) -> SBBreakpointLocationRef;
1317 pub fn SBBreakpointGetLocationAtIndex(
1318 instance: SBBreakpointRef,
1319 index: u32,
1320 ) -> SBBreakpointLocationRef;
1321 pub fn SBBreakpointSetEnabled(instance: SBBreakpointRef, enable: bool);
1322 pub fn SBBreakpointIsEnabled(instance: SBBreakpointRef) -> bool;
1323 pub fn SBBreakpointSetOneShot(instance: SBBreakpointRef, one_shot: bool);
1324 pub fn SBBreakpointIsOneShot(instance: SBBreakpointRef) -> bool;
1325 pub fn SBBreakpointIsInternal(instance: SBBreakpointRef) -> bool;
1326 pub fn SBBreakpointGetHitCount(instance: SBBreakpointRef) -> u32;
1327 pub fn SBBreakpointSetIgnoreCount(instance: SBBreakpointRef, count: u32);
1328 pub fn SBBreakpointGetIgnoreCount(instance: SBBreakpointRef) -> u32;
1329 pub fn SBBreakpointSetCondition(
1330 instance: SBBreakpointRef,
1331 condition: *const ::std::os::raw::c_char,
1332 );
1333 pub fn SBBreakpointGetCondition(instance: SBBreakpointRef) -> *const ::std::os::raw::c_char;
1334 pub fn SBBreakpointSetAutoContinue(instance: SBBreakpointRef, auto_continue: bool);
1335 pub fn SBBreakpointGetAutoContinue(instance: SBBreakpointRef) -> bool;
1336 pub fn SBBreakpointSetThreadID(instance: SBBreakpointRef, sb_thread_id: lldb_tid_t);
1337 pub fn SBBreakpointGetThreadID(instance: SBBreakpointRef) -> lldb_tid_t;
1338 pub fn SBBreakpointSetThreadIndex(instance: SBBreakpointRef, index: u32);
1339 pub fn SBBreakpointGetThreadIndex(instance: SBBreakpointRef) -> u32;
1340 pub fn SBBreakpointSetThreadName(
1341 instance: SBBreakpointRef,
1342 thread_name: *const ::std::os::raw::c_char,
1343 );
1344 pub fn SBBreakpointGetThreadName(instance: SBBreakpointRef) -> *const ::std::os::raw::c_char;
1345 pub fn SBBreakpointSetQueueName(
1346 instance: SBBreakpointRef,
1347 queue_name: *const ::std::os::raw::c_char,
1348 );
1349 pub fn SBBreakpointGetQueueName(instance: SBBreakpointRef) -> *const ::std::os::raw::c_char;
1350 pub fn SBBreakpointSetScriptCallbackFunction(
1351 instance: SBBreakpointRef,
1352 callback_function_name: *const ::std::os::raw::c_char,
1353 extra_args: SBStructuredDataRef,
1354 ) -> SBErrorRef;
1355 pub fn SBBreakpointSetCommandLineCommands(instance: SBBreakpointRef, commands: SBStringListRef);
1356 pub fn SBBreakpointGetCommandLineCommands(
1357 instance: SBBreakpointRef,
1358 commands: SBStringListRef,
1359 ) -> bool;
1360 pub fn SBBreakpointSetScriptCallbackBody(
1361 instance: SBBreakpointRef,
1362 script_body_text: *const ::std::os::raw::c_char,
1363 ) -> SBErrorRef;
1364 pub fn SBBreakpointAddName(
1365 instance: SBBreakpointRef,
1366 new_name: *const ::std::os::raw::c_char,
1367 ) -> bool;
1368 pub fn SBBreakpointAddNameWithErrorHandling(
1369 instance: SBBreakpointRef,
1370 new_name: *const ::std::os::raw::c_char,
1371 ) -> SBErrorRef;
1372 pub fn SBBreakpointRemoveName(
1373 instance: SBBreakpointRef,
1374 name_to_remove: *const ::std::os::raw::c_char,
1375 );
1376 pub fn SBBreakpointMatchesName(
1377 instance: SBBreakpointRef,
1378 name: *const ::std::os::raw::c_char,
1379 ) -> bool;
1380 pub fn SBBreakpointGetNames(instance: SBBreakpointRef, names: SBStringListRef);
1381 pub fn SBBreakpointGetNumResolvedLocations(instance: SBBreakpointRef) -> usize;
1382 pub fn SBBreakpointGetNumLocations(instance: SBBreakpointRef) -> usize;
1383 pub fn SBBreakpointGetDescription(instance: SBBreakpointRef, description: SBStreamRef) -> bool;
1384 pub fn SBBreakpointGetDescription2(
1385 instance: SBBreakpointRef,
1386 description: SBStreamRef,
1387 include_locations: bool,
1388 ) -> bool;
1389 pub fn SBBreakpointEventIsBreakpointEvent(event: SBEventRef) -> bool;
1390 pub fn SBBreakpointGetBreakpointEventTypeFromEvent(event: SBEventRef) -> BreakpointEventType;
1391 pub fn SBBreakpointGetBreakpointFromEvent(event: SBEventRef) -> SBBreakpointRef;
1392 pub fn SBBreakpointGetBreakpointLocationAtIndexFromEvent(
1393 event: SBEventRef,
1394 loc_idx: u32,
1395 ) -> SBBreakpointLocationRef;
1396 pub fn SBBreakpointGetNumBreakpointLocationsFromEvent(event_sp: SBEventRef) -> u32;
1397 pub fn SBBreakpointIsHardware(instance: SBBreakpointRef) -> bool;
1398 pub fn SBBreakpointAddLocation(instance: SBBreakpointRef, address: SBAddressRef) -> SBErrorRef;
1399 pub fn SBBreakpointSerializeToStructuredData(instance: SBBreakpointRef) -> SBStructuredDataRef;
1400 pub fn CreateSBBreakpointList(target: SBTargetRef) -> SBBreakpointListRef;
1401 pub fn CloneSBBreakpointList(instance: SBBreakpointListRef) -> SBBreakpointListRef;
1402 pub fn DisposeSBBreakpointList(instance: SBBreakpointListRef);
1403 pub fn SBBreakpointListGetSize(instance: SBBreakpointListRef) -> usize;
1404 pub fn SBBreakpointListGetBreakpointAtIndex(
1405 instance: SBBreakpointListRef,
1406 idx: usize,
1407 ) -> SBBreakpointRef;
1408 pub fn SBBreakpointListFindBreakpointByID(
1409 instance: SBBreakpointListRef,
1410 break_id: lldb_break_id_t,
1411 ) -> SBBreakpointRef;
1412 pub fn SBBreakpointListAppend(instance: SBBreakpointListRef, sb_bkpt: SBBreakpointRef);
1413 pub fn SBBreakpointListAppendIfUnique(
1414 instance: SBBreakpointListRef,
1415 sb_bkpt: SBBreakpointRef,
1416 ) -> bool;
1417 pub fn SBBreakpointListAppendByID(instance: SBBreakpointListRef, id: lldb_break_id_t);
1418 pub fn SBBreakpointListClear(instance: SBBreakpointListRef);
1419 pub fn CreateSBBreakpointLocation() -> SBBreakpointLocationRef;
1420 pub fn CloneSBBreakpointLocation(instance: SBBreakpointLocationRef) -> SBBreakpointLocationRef;
1421 pub fn DisposeSBBreakpointLocation(instance: SBBreakpointLocationRef);
1422 pub fn SBBreakpointLocationGetID(instance: SBBreakpointLocationRef) -> lldb_break_id_t;
1423 pub fn SBBreakpointLocationIsValid(instance: SBBreakpointLocationRef) -> bool;
1424 pub fn SBBreakpointLocationGetAddress(instance: SBBreakpointLocationRef) -> SBAddressRef;
1425 pub fn SBBreakpointLocationGetLoadAddress(instance: SBBreakpointLocationRef) -> lldb_addr_t;
1426 pub fn SBBreakpointLocationSetEnabled(instance: SBBreakpointLocationRef, enabled: bool);
1427 pub fn SBBreakpointLocationIsEnabled(instance: SBBreakpointLocationRef) -> bool;
1428 pub fn SBBreakpointLocationGetHitCount(instance: SBBreakpointLocationRef) -> u32;
1429 pub fn SBBreakpointLocationGetIgnoreCount(instance: SBBreakpointLocationRef) -> u32;
1430 pub fn SBBreakpointLocationSetIgnoreCount(instance: SBBreakpointLocationRef, n: u32);
1431 pub fn SBBreakpointLocationSetCondition(
1432 instance: SBBreakpointLocationRef,
1433 condition: *const ::std::os::raw::c_char,
1434 );
1435 pub fn SBBreakpointLocationGetCondition(
1436 instance: SBBreakpointLocationRef,
1437 ) -> *const ::std::os::raw::c_char;
1438 pub fn SBBreakpointLocationSetAutoContinue(
1439 instance: SBBreakpointLocationRef,
1440 auto_continue: bool,
1441 );
1442 pub fn SBBreakpointLocationGetAutoContinue(instance: SBBreakpointLocationRef) -> bool;
1443 pub fn SBBreakpointLocationSetScriptCallbackFunction(
1444 instance: SBBreakpointLocationRef,
1445 callback_function_name: *const ::std::os::raw::c_char,
1446 extra_args: SBStructuredDataRef,
1447 ) -> SBErrorRef;
1448 pub fn SBBreakpointLocationSetScriptCallbackBody(
1449 instance: SBBreakpointLocationRef,
1450 script_body_text: *const ::std::os::raw::c_char,
1451 ) -> SBErrorRef;
1452 pub fn SBBreakpointLocationSetCommandLineCommands(
1453 instance: SBBreakpointRef,
1454 commands: SBStringListRef,
1455 );
1456 pub fn SBBreakpointLocationGetCommandLineCommands(
1457 instance: SBBreakpointRef,
1458 commands: SBStringListRef,
1459 ) -> bool;
1460 pub fn SBBreakpointLocationSetThreadID(
1461 instance: SBBreakpointLocationRef,
1462 sb_thread_id: lldb_tid_t,
1463 );
1464 pub fn SBBreakpointLocationGetThreadID(instance: SBBreakpointLocationRef) -> lldb_tid_t;
1465 pub fn SBBreakpointLocationSetThreadIndex(instance: SBBreakpointLocationRef, index: u32);
1466 pub fn SBBreakpointLocationGetThreadIndex(instance: SBBreakpointLocationRef) -> u32;
1467 pub fn SBBreakpointLocationSetThreadName(
1468 instance: SBBreakpointLocationRef,
1469 thread_name: *const ::std::os::raw::c_char,
1470 );
1471 pub fn SBBreakpointLocationGetThreadName(
1472 instance: SBBreakpointLocationRef,
1473 ) -> *const ::std::os::raw::c_char;
1474 pub fn SBBreakpointLocationSetQueueName(
1475 instance: SBBreakpointLocationRef,
1476 queue_name: *const ::std::os::raw::c_char,
1477 );
1478 pub fn SBBreakpointLocationGetQueueName(
1479 instance: SBBreakpointLocationRef,
1480 ) -> *const ::std::os::raw::c_char;
1481 pub fn SBBreakpointLocationIsResolved(instance: SBBreakpointLocationRef) -> bool;
1482 pub fn SBBreakpointLocationGetDescription(
1483 instance: SBBreakpointLocationRef,
1484 description: SBStreamRef,
1485 level: DescriptionLevel,
1486 ) -> bool;
1487 pub fn SBBreakpointLocationGetBreakpoint(instance: SBBreakpointLocationRef) -> SBBreakpointRef;
1488 pub fn CreateSBBreakpointName() -> SBBreakpointNameRef;
1489 pub fn CreateSBBreakpointNameFromTarget(
1490 target: SBTargetRef,
1491 name: *const ::std::os::raw::c_char,
1492 ) -> SBBreakpointNameRef;
1493 pub fn CreateSBBreakpointNameFromBreakpoint(
1494 breakpoint: SBBreakpointRef,
1495 name: *const ::std::os::raw::c_char,
1496 ) -> SBBreakpointNameRef;
1497 pub fn CloneSBBreakpointName(instance: SBBreakpointNameRef) -> SBBreakpointNameRef;
1498 pub fn DisposeSBBreakpointName(instance: SBBreakpointNameRef);
1499 pub fn SBBreakpointNameIsValid(instance: SBBreakpointNameRef) -> bool;
1500 pub fn SBBreakpointNameGetName(instance: SBBreakpointNameRef) -> *const ::std::os::raw::c_char;
1501 pub fn SBBreakpointNameSetEnabled(instance: SBBreakpointNameRef, enable: bool);
1502 pub fn SBBreakpointNameIsEnabled(instance: SBBreakpointNameRef) -> bool;
1503 pub fn SBBreakpointNameSetOneShot(instance: SBBreakpointNameRef, one_shot: bool);
1504 pub fn SBBreakpointNameIsOneShot(instance: SBBreakpointNameRef) -> bool;
1505 pub fn SBBreakpointNameSetIgnoreCount(instance: SBBreakpointNameRef, count: u32);
1506 pub fn SBBreakpointNameGetIgnoreCount(instance: SBBreakpointNameRef) -> u32;
1507 pub fn SBBreakpointNameSetCondition(
1508 instance: SBBreakpointNameRef,
1509 condition: *const ::std::os::raw::c_char,
1510 );
1511 pub fn SBBreakpointNameGetCondition(
1512 instance: SBBreakpointNameRef,
1513 ) -> *const ::std::os::raw::c_char;
1514 pub fn SBBreakpointNameSetAutoContinue(instance: SBBreakpointNameRef, auto_continue: bool);
1515 pub fn SBBreakpointNameGetAutoContinue(instance: SBBreakpointNameRef) -> bool;
1516 pub fn SBBreakpointNameSetThreadID(instance: SBBreakpointNameRef, sb_thread_id: lldb_tid_t);
1517 pub fn SBBreakpointNameGetThreadID(instance: SBBreakpointNameRef) -> lldb_tid_t;
1518 pub fn SBBreakpointNameSetThreadIndex(instance: SBBreakpointNameRef, index: u32);
1519 pub fn SBBreakpointNameGetThreadIndex(instance: SBBreakpointNameRef) -> u32;
1520 pub fn SBBreakpointNameSetThreadName(
1521 instance: SBBreakpointNameRef,
1522 thread_name: *const ::std::os::raw::c_char,
1523 );
1524 pub fn SBBreakpointNameGetThreadName(
1525 instance: SBBreakpointNameRef,
1526 ) -> *const ::std::os::raw::c_char;
1527 pub fn SBBreakpointNameSetQueueName(
1528 instance: SBBreakpointNameRef,
1529 queue_name: *const ::std::os::raw::c_char,
1530 );
1531 pub fn SBBreakpointNameGetQueueName(
1532 instance: SBBreakpointNameRef,
1533 ) -> *const ::std::os::raw::c_char;
1534 pub fn SBBreakpointNameSetCallback(
1535 instance: SBBreakpointNameRef,
1536 callback: SBBreakpointHitCallback,
1537 baton: *mut ::std::os::raw::c_void,
1538 );
1539 pub fn SBBreakpointNameSetScriptCallbackFunction(
1540 instance: SBBreakpointNameRef,
1541 callback_function_name: *const ::std::os::raw::c_char,
1542 extra_args: SBStructuredDataRef,
1543 ) -> SBErrorRef;
1544 pub fn SBBreakpointNameSetCommandLineCommands(
1545 instance: SBBreakpointNameRef,
1546 commands: SBStringListRef,
1547 );
1548 pub fn SBBreakpointNameGetCommandLineCommands(
1549 instance: SBBreakpointNameRef,
1550 commands: SBStringListRef,
1551 ) -> bool;
1552 pub fn SBBreakpointNameSetScriptCallbackBody(
1553 instance: SBBreakpointNameRef,
1554 script_body_text: *const ::std::os::raw::c_char,
1555 ) -> SBErrorRef;
1556 pub fn SBBreakpointNameGetHelpString(
1557 instance: SBBreakpointNameRef,
1558 ) -> *const ::std::os::raw::c_char;
1559 pub fn SBBreakpointNameSetHelpString(
1560 instance: SBBreakpointNameRef,
1561 help_string: *const ::std::os::raw::c_char,
1562 );
1563 pub fn SBBreakpointNameGetAllowList(instance: SBBreakpointNameRef) -> bool;
1564 pub fn SBBreakpointNameSetAllowList(instance: SBBreakpointNameRef, value: bool);
1565 pub fn SBBreakpointNameGetAllowDelete(instance: SBBreakpointNameRef) -> bool;
1566 pub fn SBBreakpointNameSetAllowDelete(instance: SBBreakpointNameRef, value: bool);
1567 pub fn SBBreakpointNameGetAllowDisable(instance: SBBreakpointNameRef) -> bool;
1568 pub fn SBBreakpointNameSetAllowDisable(instance: SBBreakpointNameRef, value: bool);
1569 pub fn SBBreakpointNameGetDescription(
1570 instance: SBBreakpointNameRef,
1571 description: SBStreamRef,
1572 ) -> bool;
1573 pub fn CreateSBBroadcaster() -> SBBroadcasterRef;
1574 pub fn CreateSBBroadcaster2(name: *const ::std::os::raw::c_char) -> SBBroadcasterRef;
1575 pub fn CloneSBBroadcaster(instance: SBBroadcasterRef) -> SBBroadcasterRef;
1576 pub fn DisposeSBBroadcaster(instance: SBBroadcasterRef);
1577 pub fn SBBroadcasterIsValid(instance: SBBroadcasterRef) -> bool;
1578 pub fn SBBroadcasterClear(instance: SBBroadcasterRef);
1579 pub fn SBBroadcasterBroadcastEventByType(
1580 instance: SBBroadcasterRef,
1581 event_type: u32,
1582 unique: bool,
1583 );
1584 pub fn SBBroadcasterBroadcastEvent(instance: SBBroadcasterRef, event: SBEventRef, unique: bool);
1585 pub fn SBBroadcasterAddInitialEventsToListener(
1586 instance: SBBroadcasterRef,
1587 listener: SBListenerRef,
1588 requested_events: u32,
1589 );
1590 pub fn SBBroadcasterAddListener(
1591 instance: SBBroadcasterRef,
1592 listener: SBListenerRef,
1593 event_mask: u32,
1594 ) -> u32;
1595 pub fn SBBroadcasterGetName(instance: SBBroadcasterRef) -> *const ::std::os::raw::c_char;
1596 pub fn SBBroadcasterEventTypeHasListeners(instance: SBBroadcasterRef, event_type: u32) -> bool;
1597 pub fn SBBroadcasterRemoveListener(
1598 instance: SBBroadcasterRef,
1599 listener: SBListenerRef,
1600 event_mask: u32,
1601 ) -> bool;
1602 pub fn CreateSBCommandInterpreterRunOptions() -> SBCommandInterpreterRunOptionsRef;
1603 pub fn DisposeSBCommandInterpreterRunOptions(instance: SBCommandInterpreterRunOptionsRef);
1604 pub fn SBCommandInterpreterRunOptionsGetStopOnContinue(
1605 instance: SBCommandInterpreterRunOptionsRef,
1606 ) -> bool;
1607 pub fn SBCommandInterpreterRunOptionsSetStopOnContinue(
1608 instance: SBCommandInterpreterRunOptionsRef,
1609 arg1: bool,
1610 );
1611 pub fn SBCommandInterpreterRunOptionsGetStopOnError(
1612 instance: SBCommandInterpreterRunOptionsRef,
1613 ) -> bool;
1614 pub fn SBCommandInterpreterRunOptionsSetStopOnError(
1615 instance: SBCommandInterpreterRunOptionsRef,
1616 arg1: bool,
1617 );
1618 pub fn SBCommandInterpreterRunOptionsGetStopOnCrash(
1619 instance: SBCommandInterpreterRunOptionsRef,
1620 ) -> bool;
1621 pub fn SBCommandInterpreterRunOptionsSetStopOnCrash(
1622 instance: SBCommandInterpreterRunOptionsRef,
1623 arg1: bool,
1624 );
1625 pub fn SBCommandInterpreterRunOptionsGetEchoCommands(
1626 instance: SBCommandInterpreterRunOptionsRef,
1627 ) -> bool;
1628 pub fn SBCommandInterpreterRunOptionsSetEchoCommands(
1629 instance: SBCommandInterpreterRunOptionsRef,
1630 arg1: bool,
1631 );
1632 pub fn SBCommandInterpreterRunOptionsGetEchoCommentCommands(
1633 instance: SBCommandInterpreterRunOptionsRef,
1634 ) -> bool;
1635 pub fn SBCommandInterpreterRunOptionsSetEchoCommentCommands(
1636 instance: SBCommandInterpreterRunOptionsRef,
1637 echo: bool,
1638 );
1639 pub fn SBCommandInterpreterRunOptionsGetPrintResults(
1640 instance: SBCommandInterpreterRunOptionsRef,
1641 ) -> bool;
1642 pub fn SBCommandInterpreterRunOptionsSetPrintResults(
1643 instance: SBCommandInterpreterRunOptionsRef,
1644 arg1: bool,
1645 );
1646 pub fn SBCommandInterpreterRunOptionsGetAddToHistory(
1647 instance: SBCommandInterpreterRunOptionsRef,
1648 ) -> bool;
1649 pub fn SBCommandInterpreterRunOptionsSetAddToHistory(
1650 instance: SBCommandInterpreterRunOptionsRef,
1651 arg1: bool,
1652 );
1653 pub fn CloneSBCommandInterpreter(instance: SBCommandInterpreterRef) -> SBCommandInterpreterRef;
1654 pub fn DisposeSBCommandInterpreter(instance: SBCommandInterpreterRef);
1655 pub fn SBCommandInterpreterGetArgumentTypeAsCString(
1656 arg_type: CommandArgumentType,
1657 ) -> *const ::std::os::raw::c_char;
1658 pub fn SBCommandInterpreterGetArgumentDescriptionAsCString(
1659 arg_type: CommandArgumentType,
1660 ) -> *const ::std::os::raw::c_char;
1661 pub fn SBCommandInterpreterEventIsCommandInterpreterEvent(event: SBEventRef) -> bool;
1662 pub fn SBCommandInterpreterIsValid(instance: SBCommandInterpreterRef) -> bool;
1663 pub fn SBCommandInterpreterCommandExists(
1664 instance: SBCommandInterpreterRef,
1665 cmd: *const ::std::os::raw::c_char,
1666 ) -> bool;
1667 pub fn SBCommandInterpreterAliasExists(
1668 instance: SBCommandInterpreterRef,
1669 cmd: *const ::std::os::raw::c_char,
1670 ) -> bool;
1671 pub fn SBCommandInterpreterGetBroadcaster(
1672 instance: SBCommandInterpreterRef,
1673 ) -> SBBroadcasterRef;
1674 pub fn SBCommandInterpreterGetBroadcasterClass() -> *const ::std::os::raw::c_char;
1675 pub fn SBCommandInterpreterHasCommands(instance: SBCommandInterpreterRef) -> bool;
1676 pub fn SBCommandInterpreterHasAliases(instance: SBCommandInterpreterRef) -> bool;
1677 pub fn SBCommandInterpreterHasAliasOptions(instance: SBCommandInterpreterRef) -> bool;
1678 pub fn SBCommandInterpreterGetProcess(instance: SBCommandInterpreterRef) -> SBProcessRef;
1679 pub fn SBCommandInterpreterGetDebugger(instance: SBCommandInterpreterRef) -> SBDebuggerRef;
1680 pub fn SBCommandInterpreterAddMultiwordCommand(
1681 instance: SBCommandInterpreterRef,
1682 name: *const ::std::os::raw::c_char,
1683 help: *const ::std::os::raw::c_char,
1684 ) -> SBCommandRef;
1685 pub fn SBCommandInterpreterAddCommand(
1686 instance: SBCommandInterpreterRef,
1687 name: *const ::std::os::raw::c_char,
1688 impl_: SBCommandPluginInterfaceRef,
1689 help: *const ::std::os::raw::c_char,
1690 ) -> SBCommandRef;
1691 pub fn SBCommandInterpreterSourceInitFileInHomeDirectory(
1692 instance: SBCommandInterpreterRef,
1693 result: SBCommandReturnObjectRef,
1694 );
1695 pub fn SBCommandInterpreterSourceInitFileInHomeDirectory2(
1696 instance: SBCommandInterpreterRef,
1697 result: SBCommandReturnObjectRef,
1698 is_repl: bool,
1699 );
1700 pub fn SBCommandInterpreterSourceInitFileInCurrentWorkingDirectory(
1701 instance: SBCommandInterpreterRef,
1702 result: SBCommandReturnObjectRef,
1703 );
1704 pub fn SBCommandInterpreterHandleCommand(
1705 instance: SBCommandInterpreterRef,
1706 command_line: *const ::std::os::raw::c_char,
1707 result: SBCommandReturnObjectRef,
1708 add_to_history: bool,
1709 ) -> ReturnStatus;
1710 pub fn SBCommandInterpreterHandleCommand2(
1711 instance: SBCommandInterpreterRef,
1712 command_line: *const ::std::os::raw::c_char,
1713 exe_ctx: SBExecutionContextRef,
1714 result: SBCommandReturnObjectRef,
1715 add_to_history: bool,
1716 ) -> ReturnStatus;
1717 pub fn SBCommandInterpreterHandleCommandsFromFile(
1718 instance: SBCommandInterpreterRef,
1719 file: SBFileSpecRef,
1720 override_context: SBExecutionContextRef,
1721 options: SBCommandInterpreterRunOptionsRef,
1722 result: SBCommandReturnObjectRef,
1723 );
1724 pub fn SBCommandInterpreterHandleCompletion(
1725 instance: SBCommandInterpreterRef,
1726 current_line: *const ::std::os::raw::c_char,
1727 cursor: *const ::std::os::raw::c_char,
1728 last_char: *const ::std::os::raw::c_char,
1729 match_start_point: ::std::os::raw::c_int,
1730 max_return_elements: ::std::os::raw::c_int,
1731 matches: SBStringListRef,
1732 ) -> ::std::os::raw::c_int;
1733 pub fn SBCommandInterpreterHandleCompletion2(
1734 instance: SBCommandInterpreterRef,
1735 current_line: *const ::std::os::raw::c_char,
1736 cursor_pos: u32,
1737 match_start_point: ::std::os::raw::c_int,
1738 max_return_elements: ::std::os::raw::c_int,
1739 matches: SBStringListRef,
1740 ) -> ::std::os::raw::c_int;
1741 pub fn SBCommandInterpreterHandleCompletionWithDescriptions(
1742 instance: SBCommandInterpreterRef,
1743 current_line: *const ::std::os::raw::c_char,
1744 cursor: *const ::std::os::raw::c_char,
1745 last_char: *const ::std::os::raw::c_char,
1746 match_start_point: ::std::os::raw::c_int,
1747 max_return_elements: ::std::os::raw::c_int,
1748 matches: SBStringListRef,
1749 descriptions: SBStringListRef,
1750 ) -> ::std::os::raw::c_int;
1751 pub fn SBCommandInterpreterHandleCompletionWithDescriptions2(
1752 instance: SBCommandInterpreterRef,
1753 current_line: *const ::std::os::raw::c_char,
1754 cursor_pos: u32,
1755 match_start_point: ::std::os::raw::c_int,
1756 max_return_elements: ::std::os::raw::c_int,
1757 matches: SBStringListRef,
1758 descriptions: SBStringListRef,
1759 ) -> ::std::os::raw::c_int;
1760 pub fn SBCommandInterpreterWasInterrupted(instance: SBCommandInterpreterRef) -> bool;
1761 pub fn SBCommandInterpreterIsActive(instance: SBCommandInterpreterRef) -> bool;
1762 pub fn SBCommandInterpreterGetIOHandlerControlSequence(
1763 instance: SBCommandInterpreterRef,
1764 ch: ::std::os::raw::c_char,
1765 ) -> *const ::std::os::raw::c_char;
1766 pub fn SBCommandInterpreterGetPromptOnQuit(instance: SBCommandInterpreterRef) -> bool;
1767 pub fn SBCommandInterpreterSetPromptOnQuit(instance: SBCommandInterpreterRef, b: bool);
1768 pub fn SBCommandPluginInterfaceDoExecute(
1769 instance: SBCommandPluginInterfaceRef,
1770 arg1: SBDebuggerRef,
1771 arg2: *mut *mut ::std::os::raw::c_char,
1772 arg3: SBCommandReturnObjectRef,
1773 ) -> bool;
1774 pub fn CloneSBCommandPluginInterface(
1775 instance: SBCommandPluginInterfaceRef,
1776 ) -> SBCommandPluginInterfaceRef;
1777 pub fn DisposeSBCommandPluginInterface(instance: SBCommandPluginInterfaceRef);
1778 pub fn CreateSBCommand() -> SBCommandRef;
1779 pub fn SBCommandIsValid(instance: SBCommandRef) -> bool;
1780 pub fn SBCommandGetName(instance: SBCommandRef) -> *const ::std::os::raw::c_char;
1781 pub fn SBCommandGetHelp(instance: SBCommandRef) -> *const ::std::os::raw::c_char;
1782 pub fn SBCommandGetHelpLong(instance: SBCommandRef) -> *const ::std::os::raw::c_char;
1783 pub fn SBCommandSetHelp(instance: SBCommandRef, arg1: *const ::std::os::raw::c_char);
1784 pub fn SBCommandSetHelpLong(instance: SBCommandRef, arg1: *const ::std::os::raw::c_char);
1785 pub fn SBCommandAddMultiwordCommand(
1786 instance: SBCommandRef,
1787 name: *const ::std::os::raw::c_char,
1788 help: *const ::std::os::raw::c_char,
1789 ) -> SBCommandRef;
1790 pub fn SBCommandAddCommand(
1791 instance: SBCommandRef,
1792 name: *const ::std::os::raw::c_char,
1793 impl_: SBCommandPluginInterfaceRef,
1794 help: *const ::std::os::raw::c_char,
1795 ) -> SBCommandRef;
1796 pub fn CloneSBCommand(instance: SBCommandRef) -> SBCommandRef;
1797 pub fn DisposeSBCommand(instance: SBCommandRef);
1798 pub fn CreateSBCommandReturnObject() -> SBCommandReturnObjectRef;
1799 pub fn CloneSBCommandReturnObject(
1800 instance: SBCommandReturnObjectRef,
1801 ) -> SBCommandReturnObjectRef;
1802 pub fn DisposeSBCommandReturnObject(instance: SBCommandReturnObjectRef);
1803 pub fn SBCommandReturnObjectIsValid(instance: SBCommandReturnObjectRef) -> bool;
1804 pub fn SBCommandReturnObjectGetOutput(
1805 instance: SBCommandReturnObjectRef,
1806 ) -> *const ::std::os::raw::c_char;
1807 pub fn SBCommandReturnObjectGetError(
1808 instance: SBCommandReturnObjectRef,
1809 ) -> *const ::std::os::raw::c_char;
1810 pub fn SBCommandReturnObjectPutOutput(
1811 instance: SBCommandReturnObjectRef,
1812 file: SBFileRef,
1813 ) -> usize;
1814 pub fn SBCommandReturnObjectGetOutputSize(instance: SBCommandReturnObjectRef) -> usize;
1815 pub fn SBCommandReturnObjectGetErrorSize(instance: SBCommandReturnObjectRef) -> usize;
1816 pub fn SBCommandReturnObjectPutError(
1817 instance: SBCommandReturnObjectRef,
1818 file: SBFileRef,
1819 ) -> usize;
1820 pub fn SBCommandReturnObjectClear(instance: SBCommandReturnObjectRef);
1821 pub fn SBCommandReturnObjectGetStatus(instance: SBCommandReturnObjectRef) -> ReturnStatus;
1822 pub fn SBCommandReturnObjectSetStatus(instance: SBCommandReturnObjectRef, status: ReturnStatus);
1823 pub fn SBCommandReturnObjectSucceeded(instance: SBCommandReturnObjectRef) -> bool;
1824 pub fn SBCommandReturnObjectHasResult(instance: SBCommandReturnObjectRef) -> bool;
1825 pub fn SBCommandReturnObjectAppendMessage(
1826 instance: SBCommandReturnObjectRef,
1827 message: *const ::std::os::raw::c_char,
1828 );
1829 pub fn SBCommandReturnObjectAppendWarning(
1830 instance: SBCommandReturnObjectRef,
1831 message: *const ::std::os::raw::c_char,
1832 );
1833 pub fn SBCommandReturnObjectGetDescription(
1834 instance: SBCommandReturnObjectRef,
1835 description: SBStreamRef,
1836 ) -> bool;
1837 pub fn SBCommandReturnObjectSetImmediateOutputFile(
1838 instance: SBCommandReturnObjectRef,
1839 file: SBFileRef,
1840 );
1841 pub fn SBCommandReturnObjectSetImmediateErrorFile(
1842 instance: SBCommandReturnObjectRef,
1843 file: SBFileRef,
1844 );
1845 pub fn SBCommandReturnObjectPutCString(
1846 instance: SBCommandReturnObjectRef,
1847 string: *const ::std::os::raw::c_char,
1848 len: ::std::os::raw::c_int,
1849 );
1850 pub fn SBCommandReturnObjectPrintf(
1851 instance: SBCommandReturnObjectRef,
1852 format: *const ::std::os::raw::c_char,
1853 ...
1854 ) -> usize;
1855 pub fn SBCommandReturnObjectGetOutput2(
1856 instance: SBCommandReturnObjectRef,
1857 only_if_no_immediate: bool,
1858 ) -> *const ::std::os::raw::c_char;
1859 pub fn SBCommandReturnObjectGetError2(
1860 instance: SBCommandReturnObjectRef,
1861 only_if_no_immediate: bool,
1862 ) -> *const ::std::os::raw::c_char;
1863 pub fn SBCommandReturnObjectSetError(
1864 instance: SBCommandReturnObjectRef,
1865 error: SBErrorRef,
1866 fallback_error_cstr: *const ::std::os::raw::c_char,
1867 );
1868 pub fn SBCommandReturnObjectSetError2(
1869 instance: SBCommandReturnObjectRef,
1870 error_cstr: *const ::std::os::raw::c_char,
1871 );
1872 pub fn CreateSBCommunication() -> SBCommunicationRef;
1873 pub fn CreateSBCommunication2(
1874 broadcaster_name: *const ::std::os::raw::c_char,
1875 ) -> SBCommunicationRef;
1876 pub fn DisposeSBCommunication(instance: SBCommunicationRef);
1877 pub fn SBCommunicationIsValid(instance: SBCommunicationRef) -> bool;
1878 pub fn SBCommunicationGetBroadcaster(instance: SBCommunicationRef) -> SBBroadcasterRef;
1879 pub fn SBCommunicationGetBroadcasterClass() -> *const ::std::os::raw::c_char;
1880 pub fn SBCommunicationAdoptFileDescriptor(
1881 instance: SBCommunicationRef,
1882 fd: ::std::os::raw::c_int,
1883 owns_fd: bool,
1884 ) -> ConnectionStatus;
1885 pub fn SBCommunicationConnect(
1886 instance: SBCommunicationRef,
1887 url: *const ::std::os::raw::c_char,
1888 ) -> ConnectionStatus;
1889 pub fn SBCommunicationDisconnect(instance: SBCommunicationRef) -> ConnectionStatus;
1890 pub fn SBCommunicationIsConnected(instance: SBCommunicationRef) -> bool;
1891 pub fn SBCommunicationGetCloseOnEOF(instance: SBCommunicationRef) -> bool;
1892 pub fn SBCommunicationSetCloseOnEOF(instance: SBCommunicationRef, b: bool);
1893 pub fn SBCommunicationRead(
1894 instance: SBCommunicationRef,
1895 dst: *mut ::std::os::raw::c_void,
1896 dst_len: usize,
1897 timeout_usec: u32,
1898 status: *mut ConnectionStatus,
1899 ) -> usize;
1900 pub fn SBCommunicationWrite(
1901 instance: SBCommunicationRef,
1902 src: *mut ::std::os::raw::c_void,
1903 src_len: usize,
1904 status: *mut ConnectionStatus,
1905 ) -> usize;
1906 pub fn SBCommunicationReadThreadStart(instance: SBCommunicationRef) -> bool;
1907 pub fn SBCommunicationReadThreadStop(instance: SBCommunicationRef) -> bool;
1908 pub fn SBCommunicationReadThreadIsRunning(instance: SBCommunicationRef) -> bool;
1909 pub fn SBCommunicationSetReadThreadBytesReceivedCallback(
1910 instance: SBCommunicationRef,
1911 callback: ReadThreadBytesReceived,
1912 callback_baton: *mut ::std::os::raw::c_void,
1913 ) -> bool;
1914 pub fn CreateSBCompileUnit() -> SBCompileUnitRef;
1915 pub fn CloneSBCompileUnit(instance: SBCompileUnitRef) -> SBCompileUnitRef;
1916 pub fn DisposeSBCompileUnit(instance: SBCompileUnitRef);
1917 pub fn SBCompileUnitIsValid(instance: SBCompileUnitRef) -> bool;
1918 pub fn SBCompileUnitGetFileSpec(instance: SBCompileUnitRef) -> SBFileSpecRef;
1919 pub fn SBCompileUnitGetNumLineEntries(instance: SBCompileUnitRef) -> u32;
1920 pub fn SBCompileUnitGetLineEntryAtIndex(instance: SBCompileUnitRef, idx: u32)
1921 -> SBLineEntryRef;
1922 pub fn SBCompileUnitFindLineEntryIndex(
1923 instance: SBCompileUnitRef,
1924 start_idx: u32,
1925 line: u32,
1926 inline_file_spec: SBFileSpecRef,
1927 ) -> u32;
1928 pub fn SBCompileUnitFindLineEntryIndex2(
1929 instance: SBCompileUnitRef,
1930 start_idx: u32,
1931 line: u32,
1932 inline_file_spec: SBFileSpecRef,
1933 exact: bool,
1934 ) -> u32;
1935 pub fn SBCompileUnitGetSupportFileAtIndex(
1936 instance: SBCompileUnitRef,
1937 idx: u32,
1938 ) -> SBFileSpecRef;
1939 pub fn SBCompileUnitGetNumSupportFiles(instance: SBCompileUnitRef) -> u32;
1940 pub fn SBCompileUnitFindSupportFileIndex(
1941 instance: SBCompileUnitRef,
1942 start_idx: u32,
1943 sb_file: SBFileSpecRef,
1944 full: bool,
1945 ) -> u32;
1946 pub fn SBCompileUnitGetTypes(instance: SBCompileUnitRef, type_mask: u32) -> SBTypeListRef;
1947 pub fn SBCompileUnitGetLanguage(instance: SBCompileUnitRef) -> LanguageType;
1948 pub fn SBCompileUnitGetDescription(
1949 instance: SBCompileUnitRef,
1950 description: SBStreamRef,
1951 ) -> bool;
1952 pub fn CreateSBData() -> SBDataRef;
1953 pub fn CloneSBData(instance: SBDataRef) -> SBDataRef;
1954 pub fn DisposeSBData(instance: SBDataRef);
1955 pub fn SBDataGetAddressByteSize(instance: SBDataRef) -> u8;
1956 pub fn SBDataSetAddressByteSize(instance: SBDataRef, addr_byte_size: u8);
1957 pub fn SBDataClear(instance: SBDataRef);
1958 pub fn SBDataIsValid(instance: SBDataRef) -> bool;
1959 pub fn SBDataGetByteSize(instance: SBDataRef) -> usize;
1960 pub fn SBDataGetByteOrder(instance: SBDataRef) -> ByteOrder;
1961 pub fn SBDataSetByteOrder(instance: SBDataRef, endian: ByteOrder);
1962 pub fn SBDataGetFloat(
1963 instance: SBDataRef,
1964 error: SBErrorRef,
1965 offset: lldb_offset_t,
1966 ) -> ::std::os::raw::c_float;
1967 pub fn SBDataGetDouble(
1968 instance: SBDataRef,
1969 error: SBErrorRef,
1970 offset: lldb_offset_t,
1971 ) -> ::std::os::raw::c_double;
1972 pub fn SBDataGetLongDouble(
1973 instance: SBDataRef,
1974 error: SBErrorRef,
1975 offset: lldb_offset_t,
1976 ) -> ::std::os::raw::c_double;
1977 pub fn SBDataGetAddress(
1978 instance: SBDataRef,
1979 error: SBErrorRef,
1980 offset: lldb_offset_t,
1981 ) -> lldb_addr_t;
1982 pub fn SBDataGetUnsignedInt8(
1983 instance: SBDataRef,
1984 error: SBErrorRef,
1985 offset: lldb_offset_t,
1986 ) -> u8;
1987 pub fn SBDataGetUnsignedInt16(
1988 instance: SBDataRef,
1989 error: SBErrorRef,
1990 offset: lldb_offset_t,
1991 ) -> u16;
1992 pub fn SBDataGetUnsignedInt32(
1993 instance: SBDataRef,
1994 error: SBErrorRef,
1995 offset: lldb_offset_t,
1996 ) -> u32;
1997 pub fn SBDataGetUnsignedInt64(
1998 instance: SBDataRef,
1999 error: SBErrorRef,
2000 offset: lldb_offset_t,
2001 ) -> u64;
2002 pub fn SBDataGetSignedInt8(instance: SBDataRef, error: SBErrorRef, offset: lldb_offset_t)
2003 -> i8;
2004 pub fn SBDataGetSignedInt16(
2005 instance: SBDataRef,
2006 error: SBErrorRef,
2007 offset: lldb_offset_t,
2008 ) -> i16;
2009 pub fn SBDataGetSignedInt32(
2010 instance: SBDataRef,
2011 error: SBErrorRef,
2012 offset: lldb_offset_t,
2013 ) -> i32;
2014 pub fn SBDataGetSignedInt64(
2015 instance: SBDataRef,
2016 error: SBErrorRef,
2017 offset: lldb_offset_t,
2018 ) -> i64;
2019 pub fn SBDataGetString(
2020 instance: SBDataRef,
2021 error: SBErrorRef,
2022 offset: lldb_offset_t,
2023 ) -> *const ::std::os::raw::c_char;
2024 pub fn SBDataReadRawData(
2025 instance: SBDataRef,
2026 error: SBErrorRef,
2027 offset: lldb_offset_t,
2028 buf: *mut ::std::os::raw::c_void,
2029 size: usize,
2030 ) -> usize;
2031 pub fn SBDataGetDescription(
2032 instance: SBDataRef,
2033 description: SBStreamRef,
2034 base_addr: lldb_addr_t,
2035 ) -> bool;
2036 pub fn SBDataSetData(
2037 instance: SBDataRef,
2038 error: SBErrorRef,
2039 buf: *mut ::std::os::raw::c_void,
2040 size: usize,
2041 endian: ByteOrder,
2042 addr_size: u8,
2043 );
2044 pub fn SBDataSetDataWithOwnership(
2045 instance: SBDataRef,
2046 error: SBErrorRef,
2047 buf: *mut ::std::os::raw::c_void,
2048 size: usize,
2049 endian: ByteOrder,
2050 addr_size: u8,
2051 );
2052 pub fn SBDataAppend(instance: SBDataRef, rhs: SBDataRef) -> bool;
2053 pub fn SBDataCreateDataFromCString(
2054 endian: ByteOrder,
2055 addr_byte_size: u32,
2056 data: *const ::std::os::raw::c_char,
2057 ) -> SBDataRef;
2058 pub fn SBDataCreateDataFromUInt64Array(
2059 endian: ByteOrder,
2060 addr_byte_size: u32,
2061 array: *mut u64,
2062 array_len: usize,
2063 ) -> SBDataRef;
2064 pub fn SBDataCreateDataFromUInt32Array(
2065 endian: ByteOrder,
2066 addr_byte_size: u32,
2067 array: *mut u32,
2068 array_len: usize,
2069 ) -> SBDataRef;
2070 pub fn SBDataCreateDataFromSInt64Array(
2071 endian: ByteOrder,
2072 addr_byte_size: u32,
2073 array: *mut i64,
2074 array_len: usize,
2075 ) -> SBDataRef;
2076 pub fn SBDataCreateDataFromSInt32Array(
2077 endian: ByteOrder,
2078 addr_byte_size: u32,
2079 array: *mut i32,
2080 array_len: usize,
2081 ) -> SBDataRef;
2082 pub fn SBDataCreateDataFromDoubleArray(
2083 endian: ByteOrder,
2084 addr_byte_size: u32,
2085 array: *mut ::std::os::raw::c_double,
2086 array_len: usize,
2087 ) -> SBDataRef;
2088 pub fn SBDataSetDataFromCString(
2089 instance: SBDataRef,
2090 data: *const ::std::os::raw::c_char,
2091 ) -> bool;
2092 pub fn SBDataSetDataFromUInt64Array(
2093 instance: SBDataRef,
2094 array: *mut u64,
2095 array_len: usize,
2096 ) -> bool;
2097 pub fn SBDataSetDataFromUInt32Array(
2098 instance: SBDataRef,
2099 array: *mut u32,
2100 array_len: usize,
2101 ) -> bool;
2102 pub fn SBDataSetDataFromSInt64Array(
2103 instance: SBDataRef,
2104 array: *mut i64,
2105 array_len: usize,
2106 ) -> bool;
2107 pub fn SBDataSetDataFromSInt32Array(
2108 instance: SBDataRef,
2109 array: *mut i32,
2110 array_len: usize,
2111 ) -> bool;
2112 pub fn SBDataSetDataFromDoubleArray(
2113 instance: SBDataRef,
2114 array: *mut ::std::os::raw::c_double,
2115 array_len: usize,
2116 ) -> bool;
2117 pub fn CreateSBInputReader() -> SBInputReaderRef;
2118 pub fn CloneSBInputReader(instance: SBInputReaderRef) -> SBInputReaderRef;
2119 pub fn DisposeSBInputReader(instance: SBInputReaderRef);
2120 pub fn SBInputReaderSetIsDone(instance: SBInputReaderRef, arg1: bool);
2121 pub fn SBInputReaderIsActive(instance: SBInputReaderRef) -> bool;
2122 pub fn SBDebuggerGetBroadcasterClass() -> *const ::std::os::raw::c_char;
2123 pub fn SBDebuggerGetBroadcaster(instance: SBDebuggerRef) -> SBBroadcasterRef;
2124 pub fn SBDebuggerGetProgressFromEvent(
2125 instance: SBEventRef,
2126 progress_id: *mut u64,
2127 completed: *mut u64,
2128 total: *mut u64,
2129 is_debugger_specific: *mut bool,
2130 ) -> *const ::std::os::raw::c_char;
2131 pub fn SBDebuggerInitialize();
2132 pub fn SBDebuggerTerminate();
2133 pub fn CloneSBDebugger(instance: SBDebuggerRef) -> SBDebuggerRef;
2134 pub fn SBDebuggerCreate() -> SBDebuggerRef;
2135 pub fn SBDebuggerCreate2(source_init_files: bool) -> SBDebuggerRef;
2136 pub fn SBDebuggerDestroy(debugger: SBDebuggerRef);
2137 pub fn SBDebuggerMemoryPressureDetected();
2138 pub fn CreateSBDebugger() -> SBDebuggerRef;
2139 pub fn DisposeSBDebugger(instance: SBDebuggerRef);
2140 pub fn SBDebuggerIsValid(instance: SBDebuggerRef) -> bool;
2141 pub fn SBDebuggerClear(instance: SBDebuggerRef);
2142 pub fn SBDebuggerSetAsync(instance: SBDebuggerRef, b: bool);
2143 pub fn SBDebuggerGetAsync(instance: SBDebuggerRef) -> bool;
2144 pub fn SBDebuggerSkipLLDBInitFiles(instance: SBDebuggerRef, b: bool);
2145 pub fn SBDebuggerSkipAppInitFiles(instance: SBDebuggerRef, b: bool);
2146 pub fn SBDebuggerSetInputString(
2147 instance: SBDebuggerRef,
2148 data: *const ::std::os::raw::c_char,
2149 ) -> SBErrorRef;
2150 pub fn SBDebuggerSetInputFile(instance: SBDebuggerRef, file: SBFileRef) -> SBErrorRef;
2151 pub fn SBDebuggerSetOutputFile(instance: SBDebuggerRef, file: SBFileRef) -> SBErrorRef;
2152 pub fn SBDebuggerSetErrorFile(instance: SBDebuggerRef, file: SBFileRef) -> SBErrorRef;
2153 pub fn SBDebuggerGetInputFile(instance: SBDebuggerRef) -> SBFileRef;
2154 pub fn SBDebuggerGetOutputFile(instance: SBDebuggerRef) -> SBFileRef;
2155 pub fn SBDebuggerGetErrorFile(instance: SBDebuggerRef) -> SBFileRef;
2156 pub fn SBDebuggerSaveInputTerminalState(instance: SBDebuggerRef);
2157 pub fn SBDebuggerRestoreInputTerminalState(instance: SBDebuggerRef);
2158 pub fn SBDebuggerGetCommandInterpreter(instance: SBDebuggerRef) -> SBCommandInterpreterRef;
2159 pub fn SBDebuggerHandleCommand(instance: SBDebuggerRef, command: *const ::std::os::raw::c_char);
2160 pub fn SBDebuggerGetListener(instance: SBDebuggerRef) -> SBListenerRef;
2161 pub fn SBDebuggerHandleProcessEvent(
2162 instance: SBDebuggerRef,
2163 process: SBProcessRef,
2164 event: SBEventRef,
2165 out: SBFileRef,
2166 err: SBFileRef,
2167 );
2168 pub fn SBDebuggerCreateTarget(
2169 instance: SBDebuggerRef,
2170 filename: *const ::std::os::raw::c_char,
2171 target_triple: *const ::std::os::raw::c_char,
2172 platform_name: *const ::std::os::raw::c_char,
2173 add_dependent_modules: bool,
2174 error: SBErrorRef,
2175 ) -> SBTargetRef;
2176 pub fn SBDebuggerCreateTargetWithFileAndTargetTriple(
2177 instance: SBDebuggerRef,
2178 filename: *const ::std::os::raw::c_char,
2179 target_triple: *const ::std::os::raw::c_char,
2180 ) -> SBTargetRef;
2181 pub fn SBDebuggerCreateTargetWithFileAndArch(
2182 instance: SBDebuggerRef,
2183 filename: *const ::std::os::raw::c_char,
2184 archname: *const ::std::os::raw::c_char,
2185 ) -> SBTargetRef;
2186 pub fn SBDebuggerCreateTarget2(
2187 instance: SBDebuggerRef,
2188 filename: *const ::std::os::raw::c_char,
2189 ) -> SBTargetRef;
2190 pub fn SBDebuggerGetDummyTarget(instance: SBDebuggerRef) -> SBTargetRef;
2191 pub fn SBDebuggerDeleteTarget(instance: SBDebuggerRef, target: SBTargetRef) -> bool;
2192 pub fn SBDebuggerGetTargetAtIndex(instance: SBDebuggerRef, idx: u32) -> SBTargetRef;
2193 pub fn SBDebuggerGetIndexOfTarget(instance: SBDebuggerRef, target: SBTargetRef) -> u32;
2194 pub fn SBDebuggerFindTargetWithProcessID(
2195 instance: SBDebuggerRef,
2196 pid: lldb_pid_t,
2197 ) -> SBTargetRef;
2198 pub fn SBDebuggerFindTargetWithFileAndArch(
2199 instance: SBDebuggerRef,
2200 filename: *const ::std::os::raw::c_char,
2201 arch: *const ::std::os::raw::c_char,
2202 ) -> SBTargetRef;
2203 pub fn SBDebuggerGetNumTargets(instance: SBDebuggerRef) -> u32;
2204 pub fn SBDebuggerGetSelectedTarget(instance: SBDebuggerRef) -> SBTargetRef;
2205 pub fn SBDebuggerSetSelectedTarget(instance: SBDebuggerRef, target: SBTargetRef);
2206 pub fn SBDebuggerGetSelectedPlatform(instance: SBDebuggerRef) -> SBPlatformRef;
2207 pub fn SBDebuggerSetSelectedPlatform(instance: SBDebuggerRef, platform: SBPlatformRef);
2208 pub fn SBDebuggerGetNumPlatforms(instance: SBDebuggerRef) -> u32;
2209 pub fn SBDebuggerGetPlatformAtIndex(instance: SBDebuggerRef, idx: u32) -> SBPlatformRef;
2210 pub fn SBDebuggerGetNumAvailablePlatforms(instance: SBDebuggerRef) -> u32;
2211 pub fn SBDebuggerGetAvailablePlatformInfoAtIndex(
2212 instance: SBDebuggerRef,
2213 idx: u32,
2214 ) -> SBStructuredDataRef;
2215 pub fn SBDebuggerGetSourceManager(instance: SBDebuggerRef) -> SBSourceManagerRef;
2216 pub fn SBDebuggerSetCurrentPlatform(
2217 instance: SBDebuggerRef,
2218 platform_name: *const ::std::os::raw::c_char,
2219 ) -> SBErrorRef;
2220 pub fn SBDebuggerSetCurrentPlatformSDKRoot(
2221 instance: SBDebuggerRef,
2222 sysroot: *const ::std::os::raw::c_char,
2223 ) -> bool;
2224 pub fn SBDebuggerSetUseExternalEditor(instance: SBDebuggerRef, input: bool) -> bool;
2225 pub fn SBDebuggerGetUseExternalEditor(instance: SBDebuggerRef) -> bool;
2226 pub fn SBDebuggerSetUseColor(instance: SBDebuggerRef, use_color: bool) -> bool;
2227 pub fn SBDebuggerGetUseColor(instance: SBDebuggerRef) -> bool;
2228 pub fn SBDebuggerSetUseSourceCache(instance: SBDebuggerRef, use_source_cache: bool) -> bool;
2229 pub fn SBDebuggerGetUseSourceCache(instance: SBDebuggerRef) -> bool;
2230 pub fn SBDebuggerGetDefaultArchitecture(
2231 arch_name: *mut ::std::os::raw::c_char,
2232 arch_name_len: usize,
2233 ) -> bool;
2234 pub fn SBDebuggerSetDefaultArchitecture(arch_name: *const ::std::os::raw::c_char) -> bool;
2235 pub fn SBDebuggerGetScriptingLanguage(
2236 instance: SBDebuggerRef,
2237 script_language_name: *const ::std::os::raw::c_char,
2238 ) -> ScriptLanguage;
2239 pub fn SBDebuggerGetScriptInterpreterInfo(
2240 instance: SBDebuggerRef,
2241 language: ScriptLanguage,
2242 ) -> SBStructuredDataRef;
2243 pub fn SBDebuggerGetVersionString() -> *const ::std::os::raw::c_char;
2244 pub fn SBDebuggerStateAsCString(state: StateType) -> *const ::std::os::raw::c_char;
2245 pub fn SBDebuggerStateIsRunningState(state: StateType) -> bool;
2246 pub fn SBDebuggerStateIsStoppedState(state: StateType) -> bool;
2247 pub fn SBDebuggerEnableLog(
2248 instance: SBDebuggerRef,
2249 channel: *const ::std::os::raw::c_char,
2250 categories: *const *const ::std::os::raw::c_char,
2251 ) -> bool;
2252 pub fn SBDebuggerDispatchInput(
2253 instance: SBDebuggerRef,
2254 baton: *mut ::std::os::raw::c_void,
2255 data: *const ::std::os::raw::c_void,
2256 data_len: usize,
2257 );
2258 pub fn SBDebuggerDispatchInput2(
2259 instance: SBDebuggerRef,
2260 data: *const ::std::os::raw::c_void,
2261 data_len: usize,
2262 );
2263 pub fn SBDebuggerDispatchInputInterrupt(instance: SBDebuggerRef);
2264 pub fn SBDebuggerDispatchInputEndOfFile(instance: SBDebuggerRef);
2265 pub fn SBDebuggerPushInputReader(instance: SBDebuggerRef, reader: SBInputReaderRef);
2266 pub fn SBDebuggerGetInstanceName(instance: SBDebuggerRef) -> *const ::std::os::raw::c_char;
2267 pub fn SBDebuggerFindDebuggerWithID(id: ::std::os::raw::c_int) -> SBDebuggerRef;
2268 pub fn SBDebuggerSetInternalVariable(
2269 var_name: *const ::std::os::raw::c_char,
2270 value: *const ::std::os::raw::c_char,
2271 debugger_instance_name: *const ::std::os::raw::c_char,
2272 ) -> SBErrorRef;
2273 pub fn SBDebuggerGetInternalVariableValue(
2274 var_name: *const ::std::os::raw::c_char,
2275 debugger_instance_name: *const ::std::os::raw::c_char,
2276 ) -> SBStringListRef;
2277 pub fn SBDebuggerGetDescription(instance: SBDebuggerRef, description: SBStreamRef) -> bool;
2278 pub fn SBDebuggerGetTerminalWidth(instance: SBDebuggerRef) -> u32;
2279 pub fn SBDebuggerSetTerminalWidth(instance: SBDebuggerRef, term_width: u32);
2280 pub fn SBDebuggerGetID(instance: SBDebuggerRef) -> lldb_user_id_t;
2281 pub fn SBDebuggerGetPrompt(instance: SBDebuggerRef) -> *const ::std::os::raw::c_char;
2282 pub fn SBDebuggerSetPrompt(instance: SBDebuggerRef, prompt: *const ::std::os::raw::c_char);
2283 pub fn SBDebuggerGetScriptLanguage(instance: SBDebuggerRef) -> ScriptLanguage;
2284 pub fn SBDebuggerSetScriptLanguage(instance: SBDebuggerRef, script_lang: ScriptLanguage);
2285 pub fn SBDebuggerGetREPLLanguage(instance: SBDebuggerRef) -> LanguageType;
2286 pub fn SBDebuggerSetREPLLanguage(instance: SBDebuggerRef, repl_lang: LanguageType);
2287 pub fn SBDebuggerGetCloseInputOnEOF(instance: SBDebuggerRef) -> bool;
2288 pub fn SBDebuggerSetCloseInputOnEOF(instance: SBDebuggerRef, b: bool);
2289 pub fn SBDebuggerGetCategory(
2290 instance: SBDebuggerRef,
2291 category_name: *const ::std::os::raw::c_char,
2292 ) -> SBTypeCategoryRef;
2293 pub fn SBDebuggerCreateCategory(
2294 instance: SBDebuggerRef,
2295 category_name: *const ::std::os::raw::c_char,
2296 ) -> SBTypeCategoryRef;
2297 pub fn SBDebuggerDeleteCategory(
2298 instance: SBDebuggerRef,
2299 category_name: *const ::std::os::raw::c_char,
2300 ) -> bool;
2301 pub fn SBDebuggerGetNumCategories(instance: SBDebuggerRef) -> u32;
2302 pub fn SBDebuggerGetCategoryAtIndex(instance: SBDebuggerRef, arg1: u32) -> SBTypeCategoryRef;
2303 pub fn SBDebuggerGetDefaultCategory(instance: SBDebuggerRef) -> SBTypeCategoryRef;
2304 pub fn SBDebuggerGetFormatForType(
2305 instance: SBDebuggerRef,
2306 arg1: SBTypeNameSpecifierRef,
2307 ) -> SBTypeFormatRef;
2308 pub fn SBDebuggerGetSummaryForType(
2309 instance: SBDebuggerRef,
2310 arg1: SBTypeNameSpecifierRef,
2311 ) -> SBTypeSummaryRef;
2312 pub fn SBDebuggerGetFilterForType(
2313 instance: SBDebuggerRef,
2314 arg1: SBTypeNameSpecifierRef,
2315 ) -> SBTypeFilterRef;
2316 pub fn SBDebuggerGetSyntheticForType(
2317 instance: SBDebuggerRef,
2318 arg1: SBTypeNameSpecifierRef,
2319 ) -> SBTypeSyntheticRef;
2320 pub fn SBDebuggerRunCommandInterpreter(
2321 instance: SBDebuggerRef,
2322 auto_handle_events: bool,
2323 spawn_thread: bool,
2324 );
2325 pub fn SBDebuggerRunCommandInterpreter2(
2326 instance: SBDebuggerRef,
2327 auto_handle_events: bool,
2328 spawn_thread: bool,
2329 options: SBCommandInterpreterRunOptionsRef,
2330 num_errors: ::std::os::raw::c_int,
2331 quit_requested: bool,
2332 stopped_for_crash: bool,
2333 );
2334 pub fn SBDebuggerRunCommandInterpreter3(
2335 instance: SBDebuggerRef,
2336 options: SBCommandInterpreterRunOptionsRef,
2337 );
2338 pub fn SBDebuggerRunREPL(
2339 instance: SBDebuggerRef,
2340 language: LanguageType,
2341 repl_options: *const ::std::os::raw::c_char,
2342 ) -> SBErrorRef;
2343 pub fn CreateSBDeclaration() -> SBDeclarationRef;
2344 pub fn CloneSBDeclaration(instance: SBDeclarationRef) -> SBDeclarationRef;
2345 pub fn DisposeSBDeclaration(instance: SBDeclarationRef);
2346 pub fn SBDeclarationIsValid(instance: SBDeclarationRef) -> bool;
2347 pub fn SBDeclarationGetFileSpec(instance: SBDeclarationRef) -> SBFileSpecRef;
2348 pub fn SBDeclarationGetLine(instance: SBDeclarationRef) -> u32;
2349 pub fn SBDeclarationGetColumn(instance: SBDeclarationRef) -> u32;
2350 pub fn SBDeclarationSetFileSpec(instance: SBDeclarationRef, filespec: SBFileSpecRef);
2351 pub fn SBDeclarationSetLine(instance: SBDeclarationRef, line: u32);
2352 pub fn SBDeclarationSetColumn(instance: SBDeclarationRef, column: u32);
2353 pub fn SBDeclarationGetDescription(
2354 instance: SBDeclarationRef,
2355 description: SBStreamRef,
2356 ) -> bool;
2357 pub fn CreateSBEnvironment() -> SBEnvironmentRef;
2358 pub fn CloneSBEnvironment(instance: SBEnvironmentRef) -> SBEnvironmentRef;
2359 pub fn DisposeSBEnvironment(instance: SBEnvironmentRef);
2360 pub fn SBEnvironmentGet(instance: SBEnvironmentRef) -> *const ::std::os::raw::c_char;
2361 pub fn SBEnvironmentGetNumValues(instance: SBEnvironmentRef) -> usize;
2362 pub fn SBEnvironmentGetNameAtIndex(
2363 instance: SBEnvironmentRef,
2364 index: usize,
2365 ) -> *const ::std::os::raw::c_char;
2366 pub fn SBEnvironmentGetValueAtIndex(
2367 instance: SBEnvironmentRef,
2368 index: usize,
2369 ) -> *const ::std::os::raw::c_char;
2370 pub fn SBEnvironmentGetEntries(instance: SBEnvironmentRef) -> SBStringListRef;
2371 pub fn SBEnvironmentPutEntry(
2372 instance: SBEnvironmentRef,
2373 name_and_value: *const ::std::os::raw::c_char,
2374 );
2375 pub fn SBEnvironmentSetEntries(
2376 instance: SBEnvironmentRef,
2377 entries: SBStringListRef,
2378 append: bool,
2379 );
2380 pub fn SBEnvironmentSet(
2381 instance: SBEnvironmentRef,
2382 name: *const ::std::os::raw::c_char,
2383 value: *const ::std::os::raw::c_char,
2384 overwrite: bool,
2385 ) -> bool;
2386 pub fn SBEnvironmentUnset(
2387 instance: SBEnvironmentRef,
2388 name: *const ::std::os::raw::c_char,
2389 ) -> bool;
2390 pub fn SBEnvironmentClear(instance: SBEnvironmentRef);
2391 pub fn CreateSBError() -> SBErrorRef;
2392 pub fn CloneSBError(instance: SBErrorRef) -> SBErrorRef;
2393 pub fn DisposeSBError(instance: SBErrorRef);
2394 pub fn SBErrorGetCString(instance: SBErrorRef) -> *const ::std::os::raw::c_char;
2395 pub fn SBErrorClear(instance: SBErrorRef);
2396 pub fn SBErrorFail(instance: SBErrorRef) -> bool;
2397 pub fn SBErrorSuccess(instance: SBErrorRef) -> bool;
2398 pub fn SBErrorGetError(instance: SBErrorRef) -> u32;
2399 pub fn SBErrorGetType(instance: SBErrorRef) -> ErrorType;
2400 pub fn SBErrorSetError(instance: SBErrorRef, err: u32, type_: ErrorType);
2401 pub fn SBErrorSetErrorToErrno(instance: SBErrorRef);
2402 pub fn SBErrorSetErrorToGenericError(instance: SBErrorRef);
2403 pub fn SBErrorSetErrorString(instance: SBErrorRef, err_str: *const ::std::os::raw::c_char);
2404 pub fn SBErrorSetErrorStringWithFormat(
2405 instance: SBErrorRef,
2406 format: *const ::std::os::raw::c_char,
2407 ...
2408 ) -> ::std::os::raw::c_int;
2409 pub fn SBErrorIsValid(instance: SBErrorRef) -> bool;
2410 pub fn SBErrorGetDescription(instance: SBErrorRef, description: SBStreamRef) -> bool;
2411 pub fn CreateSBEvent() -> SBEventRef;
2412 pub fn CreateSBEvent2(
2413 event: u32,
2414 cstr: *const ::std::os::raw::c_char,
2415 cstr_len: u32,
2416 ) -> SBEventRef;
2417 pub fn CloneSBEvent(instance: SBEventRef) -> SBEventRef;
2418 pub fn DisposeSBEvent(instance: SBEventRef);
2419 pub fn SBEventIsValid(instance: SBEventRef) -> bool;
2420 pub fn SBEventGetDataFlavor(instance: SBEventRef) -> *const ::std::os::raw::c_char;
2421 pub fn SBEventGetType(instance: SBEventRef) -> u32;
2422 pub fn SBEventGetBroadcaster(instance: SBEventRef) -> SBBroadcasterRef;
2423 pub fn SBEventGetBroadcasterClass(instance: SBEventRef) -> *const ::std::os::raw::c_char;
2424 pub fn SBEventBroadcasterMatchesPtr(
2425 instance: SBEventRef,
2426 broadcaster: SBBroadcasterRef,
2427 ) -> bool;
2428 pub fn SBEventBroadcasterMatchesRef(
2429 instance: SBEventRef,
2430 broadcaster: SBBroadcasterRef,
2431 ) -> bool;
2432 pub fn SBEventClear(instance: SBEventRef);
2433 pub fn SBEventGetCStringFromEvent(event: SBEventRef) -> *const ::std::os::raw::c_char;
2434 pub fn SBEventGetDescription(instance: SBEventRef, description: SBStreamRef) -> bool;
2435 pub fn CreateSBExecutionContext() -> SBExecutionContextRef;
2436 pub fn CreateSBExecutionContext2(target: SBTargetRef) -> SBExecutionContextRef;
2437 pub fn CreateSBExecutionContext3(process: SBProcessRef) -> SBExecutionContextRef;
2438 pub fn CreateSBExecutionContext4(thread: SBThreadRef) -> SBExecutionContextRef;
2439 pub fn CreateSBExecutionContext5(frame: SBFrameRef) -> SBExecutionContextRef;
2440 pub fn CloneSBExecutionContext(instance: SBExecutionContextRef) -> SBExecutionContextRef;
2441 pub fn DisposeSBExecutionContext(instance: SBExecutionContextRef);
2442 pub fn SBExecutionContextGetTarget(instance: SBExecutionContextRef) -> SBTargetRef;
2443 pub fn SBExecutionContextGetProcess(instance: SBExecutionContextRef) -> SBProcessRef;
2444 pub fn SBExecutionContextGetThread(instance: SBExecutionContextRef) -> SBThreadRef;
2445 pub fn SBExecutionContextGetFrame(instance: SBExecutionContextRef) -> SBFrameRef;
2446 pub fn CreateSBExpressionOptions() -> SBExpressionOptionsRef;
2447 pub fn CloneSBExpressionOptions(instance: SBExpressionOptionsRef) -> SBExpressionOptionsRef;
2448 pub fn DisposeSBExpressionOptions(instance: SBExpressionOptionsRef);
2449 pub fn SBExpressionOptionsGetCoerceResultToId(instance: SBExpressionOptionsRef) -> bool;
2450 pub fn SBExpressionOptionsSetCoerceResultToId(instance: SBExpressionOptionsRef, coerce: bool);
2451 pub fn SBExpressionOptionsGetUnwindOnError(instance: SBExpressionOptionsRef) -> bool;
2452 pub fn SBExpressionOptionsSetUnwindOnError(instance: SBExpressionOptionsRef, unwind: bool);
2453 pub fn SBExpressionOptionsGetIgnoreBreakpoints(instance: SBExpressionOptionsRef) -> bool;
2454 pub fn SBExpressionOptionsSetIgnoreBreakpoints(instance: SBExpressionOptionsRef, ignore: bool);
2455 pub fn SBExpressionOptionsGetFetchDynamicValue(
2456 instance: SBExpressionOptionsRef,
2457 ) -> DynamicValueType;
2458 pub fn SBExpressionOptionsSetFetchDynamicValue(
2459 instance: SBExpressionOptionsRef,
2460 dynamic: DynamicValueType,
2461 );
2462 pub fn SBExpressionOptionsGetTimeoutInMicroSeconds(instance: SBExpressionOptionsRef) -> u32;
2463 pub fn SBExpressionOptionsSetTimeoutInMicroSeconds(
2464 instance: SBExpressionOptionsRef,
2465 timeout: u32,
2466 );
2467 pub fn SBExpressionOptionsGetOneThreadTimeoutInMicroSeconds(
2468 instance: SBExpressionOptionsRef,
2469 ) -> u32;
2470 pub fn SBExpressionOptionsSetOneThreadTimeoutInMicroSeconds(
2471 instance: SBExpressionOptionsRef,
2472 timeout: u32,
2473 );
2474 pub fn SBExpressionOptionsGetTryAllThreads(instance: SBExpressionOptionsRef) -> bool;
2475 pub fn SBExpressionOptionsSetTryAllThreads(instance: SBExpressionOptionsRef, run_others: bool);
2476 pub fn SBExpressionOptionsGetStopOthers(instance: SBExpressionOptionsRef) -> bool;
2477 pub fn SBExpressionOptionsSetStopOthers(instance: SBExpressionOptionsRef, stop_others: bool);
2478 pub fn SBExpressionOptionsGetTrapExceptions(instance: SBExpressionOptionsRef) -> bool;
2479 pub fn SBExpressionOptionsSetTrapExceptions(
2480 instance: SBExpressionOptionsRef,
2481 trap_exceptions: bool,
2482 );
2483 pub fn SBExpressionOptionsSetLanguage(instance: SBExpressionOptionsRef, language: LanguageType);
2484 pub fn SBExpressionOptionsGetGenerateDebugInfo(instance: SBExpressionOptionsRef) -> bool;
2485 pub fn SBExpressionOptionsSetGenerateDebugInfo(instance: SBExpressionOptionsRef, b: bool);
2486 pub fn SBExpressionOptionsGetSuppressPersistentResult(instance: SBExpressionOptionsRef)
2487 -> bool;
2488 pub fn SBExpressionOptionsSetSuppressPersistentResult(
2489 instance: SBExpressionOptionsRef,
2490 b: bool,
2491 );
2492 pub fn SBExpressionOptionsGetPrefix(
2493 instance: SBExpressionOptionsRef,
2494 ) -> *const ::std::os::raw::c_char;
2495 pub fn SBExpressionOptionsSetPrefix(
2496 instance: SBExpressionOptionsRef,
2497 prefix: *const ::std::os::raw::c_char,
2498 );
2499 pub fn SBExpressionOptionsSetAutoApplyFixIts(instance: SBExpressionOptionsRef, b: bool);
2500 pub fn SBExpressionOptionsGetAutoApplyFixIts(instance: SBExpressionOptionsRef) -> bool;
2501 pub fn SBExpressionOptionsGetRetriesWithFixIts(instance: SBExpressionOptionsRef) -> u64;
2502 pub fn SBExpressionOptionsSetRetriesWithFixIts(instance: SBExpressionOptionsRef, retries: u64);
2503 pub fn SBExpressionOptionsGetTopLevel(instance: SBExpressionOptionsRef) -> bool;
2504 pub fn SBExpressionOptionsSetTopLevel(instance: SBExpressionOptionsRef, b: bool);
2505 pub fn SBExpressionOptionsGetAllowJIT(instance: SBExpressionOptionsRef) -> bool;
2506 pub fn SBExpressionOptionsSetAllowJIT(instance: SBExpressionOptionsRef, b: bool);
2507 pub fn CreateSBFile() -> SBFileRef;
2508 pub fn CreateSBFile2(file: *mut FILE, transfer_ownership: bool) -> SBFileRef;
2509 pub fn CreateSBFile3(
2510 fd: ::std::os::raw::c_int,
2511 mode: *const ::std::os::raw::c_char,
2512 transfer_ownership: bool,
2513 ) -> SBFileRef;
2514 pub fn CloneSBFile(instance: SBFileRef) -> SBFileRef;
2515 pub fn DisposeSBFile(instance: SBFileRef);
2516 pub fn SBFileIsValid(instance: SBFileRef) -> bool;
2517 pub fn SBFileRead(
2518 instance: SBFileRef,
2519 buf: *mut u8,
2520 num_bytes: usize,
2521 bytes_read: *mut usize,
2522 ) -> SBErrorRef;
2523 pub fn SBFileWrite(
2524 instance: SBFileRef,
2525 buf: *const u8,
2526 num_bytes: usize,
2527 bytes_written: *mut usize,
2528 ) -> SBErrorRef;
2529 pub fn SBFileFlush(instance: SBFileRef) -> SBErrorRef;
2530 pub fn SBFileClose(instance: SBFileRef) -> SBErrorRef;
2531 pub fn CreateSBFileSpec() -> SBFileSpecRef;
2532 pub fn CreateSBFileSpec2(path: *const ::std::os::raw::c_char) -> SBFileSpecRef;
2533 pub fn CreateSBFileSpec3(path: *const ::std::os::raw::c_char, resolve: bool) -> SBFileSpecRef;
2534 pub fn CloneSBFileSpec(instance: SBFileSpecRef) -> SBFileSpecRef;
2535 pub fn DisposeSBFileSpec(instance: SBFileSpecRef);
2536 pub fn SBFileSpecIsValid(instance: SBFileSpecRef) -> bool;
2537 pub fn SBFileSpecExists(instance: SBFileSpecRef) -> bool;
2538 pub fn SBFileSpecResolveExecutableLocation(instance: SBFileSpecRef) -> bool;
2539 pub fn SBFileSpecGetFilename(instance: SBFileSpecRef) -> *const ::std::os::raw::c_char;
2540 pub fn SBFileSpecGetDirectory(instance: SBFileSpecRef) -> *const ::std::os::raw::c_char;
2541 pub fn SBFileSpecSetFilename(instance: SBFileSpecRef, filename: *const ::std::os::raw::c_char);
2542 pub fn SBFileSpecSetDirectory(
2543 instance: SBFileSpecRef,
2544 directory: *const ::std::os::raw::c_char,
2545 );
2546 pub fn SBFileSpecGetPath(
2547 instance: SBFileSpecRef,
2548 dst_path: *mut ::std::os::raw::c_char,
2549 dst_len: usize,
2550 ) -> u32;
2551 pub fn SBFileSpecResolvePath(
2552 src_path: *const ::std::os::raw::c_char,
2553 dst_path: *mut ::std::os::raw::c_char,
2554 dst_len: usize,
2555 ) -> ::std::os::raw::c_int;
2556 pub fn SBFileSpecGetDescription(instance: SBFileSpecRef, description: SBStreamRef) -> bool;
2557 pub fn SBFileSpecAppendPathComponent(
2558 instance: SBFileSpecRef,
2559 file_or_directory: *const ::std::os::raw::c_char,
2560 );
2561 pub fn CreateSBFileSpecList() -> SBFileSpecListRef;
2562 pub fn CloneSBFileSpecList(instance: SBFileSpecListRef) -> SBFileSpecListRef;
2563 pub fn DisposeSBFileSpecList(instance: SBFileSpecListRef);
2564 pub fn SBFileSpecListGetSize(instance: SBFileSpecListRef) -> u32;
2565 pub fn SBFileSpecListGetDescription(
2566 instance: SBFileSpecListRef,
2567 description: SBStreamRef,
2568 ) -> bool;
2569 pub fn SBFileSpecListAppend(instance: SBFileSpecListRef, sb_file: SBFileSpecRef);
2570 pub fn SBFileSpecListAppendIfUnique(
2571 instance: SBFileSpecListRef,
2572 sb_file: SBFileSpecRef,
2573 ) -> bool;
2574 pub fn SBFileSpecListClear(instance: SBFileSpecListRef);
2575 pub fn SBFileSpecListFindFileIndex(
2576 instance: SBFileSpecListRef,
2577 idx: u32,
2578 sb_file: SBFileSpecRef,
2579 full: bool,
2580 ) -> u32;
2581 pub fn SBFileSpecListGetFileSpecAtIndex(instance: SBFileSpecListRef, idx: u32)
2582 -> SBFileSpecRef;
2583 pub fn CreateSBFrame() -> SBFrameRef;
2584 pub fn CloneSBFrame(instance: SBFrameRef) -> SBFrameRef;
2585 pub fn DisposeSBFrame(instance: SBFrameRef);
2586 pub fn SBFrameIsEqual(instance: SBFrameRef, that: SBFrameRef) -> bool;
2587 pub fn SBFrameIsValid(instance: SBFrameRef) -> bool;
2588 pub fn SBFrameGetFrameID(instance: SBFrameRef) -> u32;
2589 pub fn SBFrameGetCFA(instance: SBFrameRef) -> lldb_addr_t;
2590 pub fn SBFrameGetPC(instance: SBFrameRef) -> lldb_addr_t;
2591 pub fn SBFrameSetPC(instance: SBFrameRef, new_pc: lldb_addr_t) -> bool;
2592 pub fn SBFrameGetSP(instance: SBFrameRef) -> lldb_addr_t;
2593 pub fn SBFrameGetFP(instance: SBFrameRef) -> lldb_addr_t;
2594 pub fn SBFrameGetPCAddress(instance: SBFrameRef) -> SBAddressRef;
2595 pub fn SBFrameGetSymbolContext(instance: SBFrameRef, resolve_scope: u32) -> SBSymbolContextRef;
2596 pub fn SBFrameGetModule(instance: SBFrameRef) -> SBModuleRef;
2597 pub fn SBFrameGetCompileUnit(instance: SBFrameRef) -> SBCompileUnitRef;
2598 pub fn SBFrameGetFunction(instance: SBFrameRef) -> SBFunctionRef;
2599 pub fn SBFrameGetSymbol(instance: SBFrameRef) -> SBSymbolRef;
2600 pub fn SBFrameGetBlock(instance: SBFrameRef) -> SBBlockRef;
2601 pub fn SBFrameGetFunctionName(instance: SBFrameRef) -> *const ::std::os::raw::c_char;
2602 pub fn SBFrameGetDisplayFunctionName(instance: SBFrameRef) -> *const ::std::os::raw::c_char;
2603 pub fn SBFrameGuessLanguage(instance: SBFrameRef) -> LanguageType;
2604 pub fn SBFrameIsInlined(instance: SBFrameRef) -> bool;
2605 pub fn SBFrameIsArtificial(instance: SBFrameRef) -> bool;
2606 pub fn SBFrameEvaluateExpression(
2607 instance: SBFrameRef,
2608 expr: *const ::std::os::raw::c_char,
2609 options: SBExpressionOptionsRef,
2610 ) -> SBValueRef;
2611 pub fn SBFrameGetFrameBlock(instance: SBFrameRef) -> SBBlockRef;
2612 pub fn SBFrameGetLineEntry(instance: SBFrameRef) -> SBLineEntryRef;
2613 pub fn SBFrameGetThread(instance: SBFrameRef) -> SBThreadRef;
2614 pub fn SBFrameDisassemble(instance: SBFrameRef) -> *const ::std::os::raw::c_char;
2615 pub fn SBFrameClear(instance: SBFrameRef);
2616 pub fn SBFrameGetVariables(
2617 instance: SBFrameRef,
2618 options: SBVariablesOptionsRef,
2619 ) -> SBValueListRef;
2620 pub fn SBFrameGetRegisters(instance: SBFrameRef) -> SBValueListRef;
2621 pub fn SBFrameFindRegister(
2622 instance: SBFrameRef,
2623 name: *const ::std::os::raw::c_char,
2624 ) -> SBValueRef;
2625 pub fn SBFrameFindVariable(
2626 instance: SBFrameRef,
2627 var_name: *const ::std::os::raw::c_char,
2628 ) -> SBValueRef;
2629 pub fn SBFrameFindVariable2(
2630 instance: SBFrameRef,
2631 var_name: *const ::std::os::raw::c_char,
2632 use_dynamic: DynamicValueType,
2633 ) -> SBValueRef;
2634 pub fn SBFrameGetValueForVariablePath(
2635 instance: SBFrameRef,
2636 var_expr_cstr: *const ::std::os::raw::c_char,
2637 use_dynamic: DynamicValueType,
2638 ) -> SBValueRef;
2639 pub fn SBFrameGetValueForVariablePath2(
2640 instance: SBFrameRef,
2641 var_path: *const ::std::os::raw::c_char,
2642 ) -> SBValueRef;
2643 pub fn SBFrameFindValue(
2644 instance: SBFrameRef,
2645 name: *const ::std::os::raw::c_char,
2646 value_type: ValueType,
2647 ) -> SBValueRef;
2648 pub fn SBFrameFindValue2(
2649 instance: SBFrameRef,
2650 name: *const ::std::os::raw::c_char,
2651 value_type: ValueType,
2652 use_dynamic: DynamicValueType,
2653 ) -> SBValueRef;
2654 pub fn SBFrameGetDescription(instance: SBFrameRef, description: SBStreamRef) -> bool;
2655 pub fn CreateSBFunction() -> SBFunctionRef;
2656 pub fn CloneSBFunction(instance: SBFunctionRef) -> SBFunctionRef;
2657 pub fn DisposeSBFunction(instance: SBFunctionRef);
2658 pub fn SBFunctionIsValid(instance: SBFunctionRef) -> bool;
2659 pub fn SBFunctionGetName(instance: SBFunctionRef) -> *const ::std::os::raw::c_char;
2660 pub fn SBFunctionGetDisplayName(instance: SBFunctionRef) -> *const ::std::os::raw::c_char;
2661 pub fn SBFunctionGetMangledName(instance: SBFunctionRef) -> *const ::std::os::raw::c_char;
2662 pub fn SBFunctionGetInstructions(
2663 instance: SBFunctionRef,
2664 target: SBTargetRef,
2665 ) -> SBInstructionListRef;
2666 pub fn SBFunctionGetInstructions2(
2667 instance: SBFunctionRef,
2668 target: SBTargetRef,
2669 flavor: *const ::std::os::raw::c_char,
2670 ) -> SBInstructionListRef;
2671 pub fn SBFunctionGetStartAddress(instance: SBFunctionRef) -> SBAddressRef;
2672 pub fn SBFunctionGetEndAddress(instance: SBFunctionRef) -> SBAddressRef;
2673 pub fn SBFunctionGetPrologueByteSize(instance: SBFunctionRef) -> u32;
2674 pub fn SBFunctionGetType(instance: SBFunctionRef) -> SBTypeRef;
2675 pub fn SBFunctionGetBlock(instance: SBFunctionRef) -> SBBlockRef;
2676 pub fn SBFunctionGetLanguage(instance: SBFunctionRef) -> LanguageType;
2677 pub fn SBFunctionGetIsOptimized(instance: SBFunctionRef) -> bool;
2678 pub fn SBFunctionGetDescription(instance: SBFunctionRef, description: SBStreamRef) -> bool;
2679 pub fn SBHostOSGetProgramFileSpec() -> SBFileSpecRef;
2680 pub fn SBHostOSGetLLDBPythonPath() -> SBFileSpecRef;
2681 pub fn SBHostOSGetLLDBPath(path_type: PathType) -> SBFileSpecRef;
2682 pub fn SBHostOSGetUserHomeDirectory() -> SBFileSpecRef;
2683 pub fn CreateSBInstruction() -> SBInstructionRef;
2684 pub fn CloneSBInstruction(instance: SBInstructionRef) -> SBInstructionRef;
2685 pub fn DisposeSBInstruction(instance: SBInstructionRef);
2686 pub fn SBInstructionIsValid(instance: SBInstructionRef) -> bool;
2687 pub fn SBInstructionGetAddress(instance: SBInstructionRef) -> SBAddressRef;
2688 pub fn SBInstructionGetMnemonic(
2689 instance: SBInstructionRef,
2690 target: SBTargetRef,
2691 ) -> *const ::std::os::raw::c_char;
2692 pub fn SBInstructionGetOperands(
2693 instance: SBInstructionRef,
2694 target: SBTargetRef,
2695 ) -> *const ::std::os::raw::c_char;
2696 pub fn SBInstructionGetComment(
2697 instance: SBInstructionRef,
2698 target: SBTargetRef,
2699 ) -> *const ::std::os::raw::c_char;
2700 pub fn SBInstructionGetData(instance: SBInstructionRef, target: SBTargetRef) -> SBDataRef;
2701 pub fn SBInstructionGetByteSize(instance: SBInstructionRef) -> usize;
2702 pub fn SBInstructionDoesBranch(instance: SBInstructionRef) -> bool;
2703 pub fn SBInstructionHasDelaySlot(instance: SBInstructionRef) -> bool;
2704 pub fn SBInstructionPrint(instance: SBInstructionRef, out: SBFileRef);
2705 pub fn SBInstructionGetDescription(
2706 instance: SBInstructionRef,
2707 description: SBStreamRef,
2708 ) -> bool;
2709 pub fn SBInstructionEmulateWithFrame(
2710 instance: SBInstructionRef,
2711 frame: SBFrameRef,
2712 evaluate_options: u32,
2713 ) -> bool;
2714 pub fn SBInstructionDumpEmulation(
2715 instance: SBInstructionRef,
2716 triple: *const ::std::os::raw::c_char,
2717 ) -> bool;
2718 pub fn SBInstructionTestEmulation(
2719 instance: SBInstructionRef,
2720 output_stream: SBStreamRef,
2721 test_file: *const ::std::os::raw::c_char,
2722 ) -> bool;
2723 pub fn CreateSBInstructionList() -> SBInstructionListRef;
2724 pub fn CloneSBInstructionList(instance: SBInstructionListRef) -> SBInstructionListRef;
2725 pub fn DisposeSBInstructionList(instance: SBInstructionListRef);
2726 pub fn SBInstructionListIsValid(instance: SBInstructionListRef) -> bool;
2727 pub fn SBInstructionListGetSize(instance: SBInstructionListRef) -> usize;
2728 pub fn SBInstructionListGetInstructionAtIndex(
2729 instance: SBInstructionListRef,
2730 idx: u32,
2731 ) -> SBInstructionRef;
2732 pub fn SBInstructionListClear(instance: SBInstructionListRef);
2733 pub fn SBInstructionListAppendInstruction(
2734 instance: SBInstructionListRef,
2735 inst: SBInstructionRef,
2736 );
2737 pub fn SBInstructionListPrint(instance: SBInstructionListRef, out: SBFileRef);
2738 pub fn SBInstructionListGetDescription(
2739 instance: SBInstructionListRef,
2740 description: SBStreamRef,
2741 ) -> bool;
2742 pub fn SBInstructionListDumpEmulationForAllInstructions(
2743 instance: SBInstructionListRef,
2744 triple: *const ::std::os::raw::c_char,
2745 ) -> bool;
2746 pub fn SBLanguageRuntimeGetLanguageTypeFromString(
2747 string: *const ::std::os::raw::c_char,
2748 ) -> LanguageType;
2749 pub fn SBLanguageRuntimeGetNameForLanguageType(
2750 language: LanguageType,
2751 ) -> *const ::std::os::raw::c_char;
2752 pub fn CreateSBLaunchInfo(argv: *const *const ::std::os::raw::c_char) -> SBLaunchInfoRef;
2753 pub fn CloneSBLaunchInfo(instance: SBLaunchInfoRef) -> SBLaunchInfoRef;
2754 pub fn DisposeSBLaunchInfo(instance: SBLaunchInfoRef);
2755 pub fn SBLaunchInfoGetProcessID(instance: SBLaunchInfoRef) -> lldb_pid_t;
2756 pub fn SBLaunchInfoGetUserID(instance: SBLaunchInfoRef) -> u32;
2757 pub fn SBLaunchInfoGetGroupID(instance: SBLaunchInfoRef) -> u32;
2758 pub fn SBLaunchInfoUserIDIsValid(instance: SBLaunchInfoRef) -> bool;
2759 pub fn SBLaunchInfoGroupIDIsValid(instance: SBLaunchInfoRef) -> bool;
2760 pub fn SBLaunchInfoSetUserID(instance: SBLaunchInfoRef, uid: u32);
2761 pub fn SBLaunchInfoSetGroupID(instance: SBLaunchInfoRef, gid: u32);
2762 pub fn SBLaunchInfoGetExecutableFile(instance: SBLaunchInfoRef) -> SBFileSpecRef;
2763 pub fn SBLaunchInfoSetExecutableFile(
2764 instance: SBLaunchInfoRef,
2765 exe_file: SBFileSpecRef,
2766 add_as_first_arg: bool,
2767 );
2768 pub fn SBLaunchInfoGetListener(instance: SBLaunchInfoRef) -> SBListenerRef;
2769 pub fn SBLaunchInfoSetListener(instance: SBLaunchInfoRef, listener: SBListenerRef);
2770 pub fn SBLaunchInfoGetNumArguments(instance: SBLaunchInfoRef) -> u32;
2771 pub fn SBLaunchInfoGetArgumentAtIndex(
2772 instance: SBLaunchInfoRef,
2773 idx: u32,
2774 ) -> *const ::std::os::raw::c_char;
2775 pub fn SBLaunchInfoSetArguments(
2776 instance: SBLaunchInfoRef,
2777 argv: *const *const ::std::os::raw::c_char,
2778 append: bool,
2779 );
2780 pub fn SBLaunchInfoGetNumEnvironmentEntries(instance: SBLaunchInfoRef) -> u32;
2781 pub fn SBLaunchInfoGetEnvironmentEntryAtIndex(
2782 instance: SBLaunchInfoRef,
2783 idx: u32,
2784 ) -> *const ::std::os::raw::c_char;
2785 pub fn SBLaunchInfoSetEnvironmentEntries(
2786 instance: SBLaunchInfoRef,
2787 envp: *const *const ::std::os::raw::c_char,
2788 append: bool,
2789 );
2790 pub fn SBLaunchInfoSetEnvironment(
2791 instance: SBLaunchInfoRef,
2792 environment: SBEnvironmentRef,
2793 append: bool,
2794 );
2795 pub fn SBLaunchInfoGetEnvironment(instance: SBLaunchInfoRef) -> SBEnvironmentRef;
2796 pub fn SBLaunchInfoClear(instance: SBLaunchInfoRef);
2797 pub fn SBLaunchInfoGetWorkingDirectory(
2798 instance: SBLaunchInfoRef,
2799 ) -> *const ::std::os::raw::c_char;
2800 pub fn SBLaunchInfoSetWorkingDirectory(
2801 instance: SBLaunchInfoRef,
2802 working_dir: *const ::std::os::raw::c_char,
2803 );
2804 pub fn SBLaunchInfoGetLaunchFlags(instance: SBLaunchInfoRef) -> u32;
2805 pub fn SBLaunchInfoSetLaunchFlags(instance: SBLaunchInfoRef, flags: u32);
2806 pub fn SBLaunchInfoGetProcessPluginName(
2807 instance: SBLaunchInfoRef,
2808 ) -> *const ::std::os::raw::c_char;
2809 pub fn SBLaunchInfoSetProcessPluginName(
2810 instance: SBLaunchInfoRef,
2811 plugin_name: *const ::std::os::raw::c_char,
2812 );
2813 pub fn SBLaunchInfoGetShell(instance: SBLaunchInfoRef) -> *const ::std::os::raw::c_char;
2814 pub fn SBLaunchInfoSetShell(instance: SBLaunchInfoRef, path: *const ::std::os::raw::c_char);
2815 pub fn SBLaunchInfoGetShellExpandArguments(instance: SBLaunchInfoRef) -> bool;
2816 pub fn SBLaunchInfoSetShellExpandArguments(instance: SBLaunchInfoRef, glob: bool);
2817 pub fn SBLaunchInfoGetResumeCount(instance: SBLaunchInfoRef) -> u32;
2818 pub fn SBLaunchInfoSetResumeCount(instance: SBLaunchInfoRef, c: u32);
2819 pub fn SBLaunchInfoAddCloseFileAction(
2820 instance: SBLaunchInfoRef,
2821 fd: ::std::os::raw::c_int,
2822 ) -> bool;
2823 pub fn SBLaunchInfoAddDuplicateFileAction(
2824 instance: SBLaunchInfoRef,
2825 fd: ::std::os::raw::c_int,
2826 dup_fd: ::std::os::raw::c_int,
2827 ) -> bool;
2828 pub fn SBLaunchInfoAddOpenFileAction(
2829 instance: SBLaunchInfoRef,
2830 fd: ::std::os::raw::c_int,
2831 path: *const ::std::os::raw::c_char,
2832 read: bool,
2833 write: bool,
2834 ) -> bool;
2835 pub fn SBLaunchInfoAddSuppressFileAction(
2836 instance: SBLaunchInfoRef,
2837 fd: ::std::os::raw::c_int,
2838 read: bool,
2839 write: bool,
2840 ) -> bool;
2841 pub fn SBLaunchInfoSetLaunchEventData(
2842 instance: SBLaunchInfoRef,
2843 data: *const ::std::os::raw::c_char,
2844 );
2845 pub fn SBLaunchInfoGetLaunchEventData(
2846 instance: SBLaunchInfoRef,
2847 ) -> *const ::std::os::raw::c_char;
2848 pub fn SBLaunchInfoGetDetachOnError(instance: SBLaunchInfoRef) -> bool;
2849 pub fn SBLaunchInfoSetDetachOnError(instance: SBLaunchInfoRef, enable: bool);
2850 pub fn SBLaunchInfoGetScriptedProcessClassName(
2851 instance: SBLaunchInfoRef,
2852 ) -> *const ::std::os::raw::c_char;
2853 pub fn SBLaunchInfoSetScriptedProcessClassName(
2854 instance: SBLaunchInfoRef,
2855 class_name: *const ::std::os::raw::c_char,
2856 );
2857 pub fn SBLaunchInfoGetScriptedProcessDictionary(
2858 instance: SBLaunchInfoRef,
2859 ) -> SBStructuredDataRef;
2860 pub fn SBLaunchInfoSetScriptedProcessDictionary(
2861 instance: SBLaunchInfoRef,
2862 dict: SBStructuredDataRef,
2863 );
2864 pub fn CreateSBLineEntry() -> SBLineEntryRef;
2865 pub fn CloneSBLineEntry(instance: SBLineEntryRef) -> SBLineEntryRef;
2866 pub fn DisposeSBLineEntry(instance: SBLineEntryRef);
2867 pub fn SBLineEntryGetStartAddress(instance: SBLineEntryRef) -> SBAddressRef;
2868 pub fn SBLineEntryGetEndAddress(instance: SBLineEntryRef) -> SBAddressRef;
2869 pub fn SBLineEntryIsValid(instance: SBLineEntryRef) -> bool;
2870 pub fn SBLineEntryGetFileSpec(instance: SBLineEntryRef) -> SBFileSpecRef;
2871 pub fn SBLineEntryGetLine(instance: SBLineEntryRef) -> u32;
2872 pub fn SBLineEntryGetColumn(instance: SBLineEntryRef) -> u32;
2873 pub fn SBLineEntrySetFileSpec(instance: SBLineEntryRef, filespec: SBFileSpecRef);
2874 pub fn SBLineEntrySetLine(instance: SBLineEntryRef, line: u32);
2875 pub fn SBLineEntrySetColumn(instance: SBLineEntryRef, column: u32);
2876 pub fn SBLineEntryGetDescription(instance: SBLineEntryRef, description: SBStreamRef) -> bool;
2877 pub fn CreateSBListener() -> SBListenerRef;
2878 pub fn CreateSBListener2(name: *const ::std::os::raw::c_char) -> SBListenerRef;
2879 pub fn CloneSBListener(instance: SBListenerRef) -> SBListenerRef;
2880 pub fn DisposeSBListener(instance: SBListenerRef);
2881 pub fn SBListenerAddEvent(instance: SBListenerRef, event: SBEventRef);
2882 pub fn SBListenerClear(instance: SBListenerRef);
2883 pub fn SBListenerIsValid(instance: SBListenerRef) -> bool;
2884 pub fn SBListenerStartListeningForEventClass(
2885 instance: SBListenerRef,
2886 debugger: SBDebuggerRef,
2887 broadcaster_class: *const ::std::os::raw::c_char,
2888 event_mask: u32,
2889 ) -> u32;
2890 pub fn SBListenerStopListeningForEventClass(
2891 instance: SBListenerRef,
2892 debugger: SBDebuggerRef,
2893 broadcaster_class: *const ::std::os::raw::c_char,
2894 event_mask: u32,
2895 ) -> bool;
2896 pub fn SBListenerStartListeningForEvents(
2897 instance: SBListenerRef,
2898 broadcaster: SBBroadcasterRef,
2899 event_mask: u32,
2900 ) -> u32;
2901 pub fn SBListenerStopListeningForEvents(
2902 instance: SBListenerRef,
2903 broadcaster: SBBroadcasterRef,
2904 event_mask: u32,
2905 ) -> bool;
2906 pub fn SBListenerWaitForEvent(
2907 instance: SBListenerRef,
2908 num_seconds: u32,
2909 event: SBEventRef,
2910 ) -> bool;
2911 pub fn SBListenerWaitForEventForBroadcaster(
2912 instance: SBListenerRef,
2913 num_seconds: u32,
2914 broadcaster: SBBroadcasterRef,
2915 sb_event: SBEventRef,
2916 ) -> bool;
2917 pub fn SBListenerWaitForEventForBroadcasterWithType(
2918 instance: SBListenerRef,
2919 num_seconds: u32,
2920 broadcaster: SBBroadcasterRef,
2921 event_type_mask: u32,
2922 sb_event: SBEventRef,
2923 ) -> bool;
2924 pub fn SBListenerPeekAtNextEvent(instance: SBListenerRef, sb_event: SBEventRef) -> bool;
2925 pub fn SBListenerPeekAtNextEventForBroadcaster(
2926 instance: SBListenerRef,
2927 broadcaster: SBBroadcasterRef,
2928 sb_event: SBEventRef,
2929 ) -> bool;
2930 pub fn SBListenerPeekAtNextEventForBroadcasterWithType(
2931 instance: SBListenerRef,
2932 broadcaster: SBBroadcasterRef,
2933 event_type_mask: u32,
2934 sb_event: SBEventRef,
2935 ) -> bool;
2936 pub fn SBListenerGetNextEvent(instance: SBListenerRef, sb_event: SBEventRef) -> bool;
2937 pub fn SBListenerGetNextEventForBroadcaster(
2938 instance: SBListenerRef,
2939 broadcaster: SBBroadcasterRef,
2940 sb_event: SBEventRef,
2941 ) -> bool;
2942 pub fn SBListenerGetNextEventForBroadcasterWithType(
2943 instance: SBListenerRef,
2944 broadcaster: SBBroadcasterRef,
2945 event_type_mask: u32,
2946 sb_event: SBEventRef,
2947 ) -> bool;
2948 pub fn SBListenerHandleBroadcastEvent(instance: SBListenerRef, event: SBEventRef) -> bool;
2949 pub fn CreateSBMemoryRegionInfo() -> SBMemoryRegionInfoRef;
2950 pub fn CreateSBMemoryRegionInfo2(
2951 name: *const ::std::os::raw::c_char,
2952 begin: lldb_addr_t,
2953 end: lldb_addr_t,
2954 permissions: u32,
2955 mapped: bool,
2956 stack_memory: bool,
2957 ) -> SBMemoryRegionInfoRef;
2958 pub fn CloneSBMemoryRegionInfo(instance: SBMemoryRegionInfoRef) -> SBMemoryRegionInfoRef;
2959 pub fn DisposeSBMemoryRegionInfo(instance: SBMemoryRegionInfoRef);
2960 pub fn SBMemoryRegionInfoClear(instance: SBMemoryRegionInfoRef);
2961 pub fn SBMemoryRegionInfoGetRegionBase(instance: SBMemoryRegionInfoRef) -> lldb_addr_t;
2962 pub fn SBMemoryRegionInfoGetRegionEnd(instance: SBMemoryRegionInfoRef) -> lldb_addr_t;
2963 pub fn SBMemoryRegionInfoIsReadable(instance: SBMemoryRegionInfoRef) -> bool;
2964 pub fn SBMemoryRegionInfoIsWritable(instance: SBMemoryRegionInfoRef) -> bool;
2965 pub fn SBMemoryRegionInfoIsExecutable(instance: SBMemoryRegionInfoRef) -> bool;
2966 pub fn SBMemoryRegionInfoIsMapped(instance: SBMemoryRegionInfoRef) -> bool;
2967 pub fn SBMemoryRegionInfoGetName(
2968 instance: SBMemoryRegionInfoRef,
2969 ) -> *const ::std::os::raw::c_char;
2970 pub fn SBMemoryRegionInfoHasDirtyMemoryPageList(instance: SBMemoryRegionInfoRef) -> bool;
2971 pub fn SBMemoryRegionInfoGetNumDirtyPages(instance: SBMemoryRegionInfoRef) -> u32;
2972 pub fn SBMemoryRegionInfoGetDirtyPageAddressAtIndex(
2973 instance: SBMemoryRegionInfoRef,
2974 idx: u32,
2975 ) -> lldb_addr_t;
2976 pub fn SBMemoryRegionInfoGetPageSize(instance: SBMemoryRegionInfoRef) -> i32;
2977 pub fn SBMemoryRegionInfoGetDescription(
2978 instance: SBMemoryRegionInfoRef,
2979 description: SBStreamRef,
2980 ) -> bool;
2981 pub fn CreateSBMemoryRegionInfoList() -> SBMemoryRegionInfoListRef;
2982 pub fn CloneSBMemoryRegionInfoList(
2983 instance: SBMemoryRegionInfoListRef,
2984 ) -> SBMemoryRegionInfoListRef;
2985 pub fn DisposeSBMemoryRegionInfoList(instance: SBMemoryRegionInfoListRef);
2986 pub fn SBMemoryRegionInfoListGetSize(instance: SBMemoryRegionInfoListRef) -> u32;
2987 pub fn SBMemoryRegionInfoListGetMemoryRegionContainingAddress(
2988 instance: SBMemoryRegionInfoListRef,
2989 addr: lldb_addr_t,
2990 region: SBMemoryRegionInfoRef,
2991 ) -> bool;
2992 pub fn SBMemoryRegionInfoListGetMemoryRegionAtIndex(
2993 instance: SBMemoryRegionInfoListRef,
2994 idx: u32,
2995 region: SBMemoryRegionInfoRef,
2996 ) -> bool;
2997 pub fn SBMemoryRegionInfoListAppend(
2998 instance: SBMemoryRegionInfoListRef,
2999 region: SBMemoryRegionInfoRef,
3000 );
3001 pub fn SBMemoryRegionInfoListAppendList(
3002 instance: SBMemoryRegionInfoListRef,
3003 region_list: SBMemoryRegionInfoListRef,
3004 );
3005 pub fn SBMemoryRegionInfoListClear(instance: SBMemoryRegionInfoListRef);
3006 pub fn CreateSBModule() -> SBModuleRef;
3007 pub fn CreateSBModule2(module_spec: SBModuleSpecRef) -> SBModuleRef;
3008 pub fn CreateSBModule3(process: SBProcessRef, header_addr: lldb_addr_t) -> SBModuleRef;
3009 pub fn CloneSBModule(instance: SBModuleRef) -> SBModuleRef;
3010 pub fn DisposeSBModule(instance: SBModuleRef);
3011 pub fn SBModuleIsValid(instance: SBModuleRef) -> bool;
3012 pub fn SBModuleClear(instance: SBModuleRef);
3013 pub fn SBModuleIsFileBacked(instance: SBModuleRef) -> bool;
3014 pub fn SBModuleGetFileSpec(instance: SBModuleRef) -> SBFileSpecRef;
3015 pub fn SBModuleGetPlatformFileSpec(instance: SBModuleRef) -> SBFileSpecRef;
3016 pub fn SBModuleSetPlatformFileSpec(instance: SBModuleRef, platform_file: SBFileSpecRef)
3017 -> bool;
3018 pub fn SBModuleGetRemoteInstallFileSpec(instance: SBModuleRef) -> SBFileSpecRef;
3019 pub fn SBModuleSetRemoteInstallFileSpec(instance: SBModuleRef, file: SBFileSpecRef) -> bool;
3020 pub fn SBModuleGetByteOrder(instance: SBModuleRef) -> ByteOrder;
3021 pub fn SBModuleGetAddressByteSize(instance: SBModuleRef) -> u32;
3022 pub fn SBModuleGetTriple(instance: SBModuleRef) -> *const ::std::os::raw::c_char;
3023 pub fn SBModuleGetUUIDBytes(instance: SBModuleRef) -> *const u8;
3024 pub fn SBModuleGetUUIDString(instance: SBModuleRef) -> *const ::std::os::raw::c_char;
3025 pub fn SBModuleFindSection(
3026 instance: SBModuleRef,
3027 sect_name: *const ::std::os::raw::c_char,
3028 ) -> SBSectionRef;
3029 pub fn SBModuleResolveFileAddress(instance: SBModuleRef, vm_addr: lldb_addr_t) -> SBAddressRef;
3030 pub fn SBModuleResolveSymbolContextForAddress(
3031 instance: SBModuleRef,
3032 addr: SBAddressRef,
3033 resolve_scope: u32,
3034 ) -> SBSymbolContextRef;
3035 pub fn SBModuleGetDescription(instance: SBModuleRef, description: SBStreamRef) -> bool;
3036 pub fn SBModuleGetNumCompileUnits(instance: SBModuleRef) -> u32;
3037 pub fn SBModuleGetCompileUnitAtIndex(instance: SBModuleRef, arg1: u32) -> SBCompileUnitRef;
3038 pub fn SBModuleGetNumSymbols(instance: SBModuleRef) -> usize;
3039 pub fn SBModuleGetSymbolAtIndex(instance: SBModuleRef, idx: usize) -> SBSymbolRef;
3040 pub fn SBModuleFindSymbol(
3041 instance: SBModuleRef,
3042 name: *const ::std::os::raw::c_char,
3043 type_: SymbolType,
3044 ) -> SBSymbolRef;
3045 pub fn SBModuleFindSymbols(
3046 instance: SBModuleRef,
3047 name: *const ::std::os::raw::c_char,
3048 type_: SymbolType,
3049 ) -> SBSymbolContextListRef;
3050 pub fn SBModuleGetNumSections(instance: SBModuleRef) -> usize;
3051 pub fn SBModuleGetSectionAtIndex(instance: SBModuleRef, idx: usize) -> SBSectionRef;
3052 pub fn SBModuleFindFunctions(
3053 instance: SBModuleRef,
3054 name: *const ::std::os::raw::c_char,
3055 name_type_mask: u32,
3056 ) -> SBSymbolContextListRef;
3057 pub fn SBModuleFindGlobalVariables(
3058 instance: SBModuleRef,
3059 target: SBTargetRef,
3060 name: *const ::std::os::raw::c_char,
3061 max_matches: u32,
3062 ) -> SBValueListRef;
3063 pub fn SBModuleFindFirstGlobalVariable(
3064 instance: SBModuleRef,
3065 target: SBTargetRef,
3066 name: *const ::std::os::raw::c_char,
3067 ) -> SBValueRef;
3068 pub fn SBModuleFindFirstType(
3069 instance: SBModuleRef,
3070 name: *const ::std::os::raw::c_char,
3071 ) -> SBTypeRef;
3072 pub fn SBModuleFindTypes(
3073 instance: SBModuleRef,
3074 type_: *const ::std::os::raw::c_char,
3075 ) -> SBTypeListRef;
3076 pub fn SBModuleGetTypeByID(instance: SBModuleRef, uid: lldb_user_id_t) -> SBTypeRef;
3077 pub fn SBModuleGetBasicType(instance: SBModuleRef, type_: BasicType) -> SBTypeRef;
3078 pub fn SBModuleGetTypes(instance: SBModuleRef, type_mask: u32) -> SBTypeListRef;
3079 pub fn SBModuleGetVersion(instance: SBModuleRef, versions: *mut u32, num_versions: u32) -> u32;
3080 pub fn SBModuleGetSymbolFileSpec(instance: SBModuleRef) -> SBFileSpecRef;
3081 pub fn SBModuleGetObjectFileHeaderAddress(instance: SBModuleRef) -> SBAddressRef;
3082 pub fn SBModuleGetObjectFileEntryPointAddress(instance: SBModuleRef) -> SBAddressRef;
3083 pub fn SBModuleGetNumberAllocatedModules() -> u32;
3084 pub fn SBModuleGarbageCollectAllocatedModules();
3085 pub fn CreateSBModuleSpec() -> SBModuleSpecRef;
3086 pub fn CloneSBModuleSpec(instance: SBModuleSpecRef) -> SBModuleSpecRef;
3087 pub fn DisposeSBModuleSpec(instance: SBModuleSpecRef);
3088 pub fn SBModuleSpecIsValid(instance: SBModuleSpecRef) -> bool;
3089 pub fn SBModuleSpecClear(instance: SBModuleSpecRef);
3090 pub fn SBModuleSpecGetFileSpec(instance: SBModuleSpecRef) -> SBFileSpecRef;
3091 pub fn SBModuleSpecSetFileSpec(instance: SBModuleSpecRef, fspec: SBFileSpecRef);
3092 pub fn SBModuleSpecGetPlatformFileSpec(instance: SBModuleSpecRef) -> SBFileSpecRef;
3093 pub fn SBModuleSpecSetPlatformFileSpec(instance: SBModuleSpecRef, fspec: SBFileSpecRef);
3094 pub fn SBModuleSpecGetSymbolFileSpec(instance: SBModuleSpecRef) -> SBFileSpecRef;
3095 pub fn SBModuleSpecSetSymbolFileSpec(instance: SBModuleSpecRef, fspec: SBFileSpecRef);
3096 pub fn SBModuleSpecGetObjectName(instance: SBModuleSpecRef) -> *const ::std::os::raw::c_char;
3097 pub fn SBModuleSpecSetObjectName(
3098 instance: SBModuleSpecRef,
3099 name: *const ::std::os::raw::c_char,
3100 );
3101 pub fn SBModuleSpecGetTriple(instance: SBModuleSpecRef) -> *const ::std::os::raw::c_char;
3102 pub fn SBModuleSpecSetTriple(instance: SBModuleSpecRef, triple: *const ::std::os::raw::c_char);
3103 pub fn SBModuleSpecGetUUIDBytes(instance: SBModuleSpecRef) -> *const u8;
3104 pub fn SBModuleSpecGetUUIDLength(instance: SBModuleSpecRef) -> usize;
3105 pub fn SBModuleSpecSetUUIDBytes(
3106 instance: SBModuleSpecRef,
3107 uuid: *const u8,
3108 uuid_len: usize,
3109 ) -> bool;
3110 pub fn SBModuleSpecGetDescription(instance: SBModuleSpecRef, description: SBStreamRef) -> bool;
3111 pub fn CreateSBModuleSpecList() -> SBModuleSpecListRef;
3112 pub fn CloneSBModuleSpecList(instance: SBModuleSpecListRef) -> SBModuleSpecListRef;
3113 pub fn DisposeSBModuleSpecList(instance: SBModuleSpecListRef);
3114 pub fn SBModuleSpecListGetModuleSpecifications(
3115 path: *const ::std::os::raw::c_char,
3116 ) -> SBModuleSpecListRef;
3117 pub fn SBModuleSpecListAppend(instance: SBModuleSpecListRef, spec: SBModuleSpecRef);
3118 pub fn SBModuleSpecListAppendList(
3119 instance: SBModuleSpecListRef,
3120 spec_list: SBModuleSpecListRef,
3121 );
3122 pub fn SBModuleSpecListFindFirstMatchingSpec(
3123 instance: SBModuleSpecListRef,
3124 match_spec: SBModuleSpecRef,
3125 ) -> SBModuleSpecRef;
3126 pub fn SBModuleSpecListFindMatchingSpecs(
3127 instance: SBModuleSpecListRef,
3128 match_spec: SBModuleSpecRef,
3129 ) -> SBModuleSpecListRef;
3130 pub fn SBModuleSpecListGetSize(instance: SBModuleSpecListRef) -> usize;
3131 pub fn SBModuleSpecListGetSpecAtIndex(
3132 instance: SBModuleSpecListRef,
3133 i: usize,
3134 ) -> SBModuleSpecRef;
3135 pub fn SBModuleSpecListGetDescription(
3136 instance: SBModuleSpecListRef,
3137 description: SBStreamRef,
3138 ) -> bool;
3139 pub fn CreateSBPlatformConnectOptions(
3140 url: *const ::std::os::raw::c_char,
3141 ) -> SBPlatformConnectOptionsRef;
3142 pub fn CloneSBPlatformConnectOptions(
3143 instance: SBPlatformConnectOptionsRef,
3144 ) -> SBPlatformConnectOptionsRef;
3145 pub fn DisposeSBPlatformConnectOptions(instance: SBPlatformConnectOptionsRef);
3146 pub fn SBPlatformConnectOptionsGetURL(
3147 instance: SBPlatformConnectOptionsRef,
3148 ) -> *const ::std::os::raw::c_char;
3149 pub fn SBPlatformConnectOptionsSetURL(
3150 instance: SBPlatformConnectOptionsRef,
3151 url: *const ::std::os::raw::c_char,
3152 );
3153 pub fn SBPlatformConnectOptionsGetRsyncEnabled(instance: SBPlatformConnectOptionsRef) -> bool;
3154 pub fn SBPlatformConnectOptionsEnableRsync(
3155 instance: SBPlatformConnectOptionsRef,
3156 options: *const ::std::os::raw::c_char,
3157 remote_path_prefix: *const ::std::os::raw::c_char,
3158 omit_remote_hostname: bool,
3159 );
3160 pub fn SBPlatformConnectOptionsDisableRsync(instance: SBPlatformConnectOptionsRef);
3161 pub fn SBPlatformConnectOptionsGetLocalCacheDirectory(
3162 instance: SBPlatformConnectOptionsRef,
3163 ) -> *const ::std::os::raw::c_char;
3164 pub fn SBPlatformConnectOptionsSetLocalCacheDirectory(
3165 instance: SBPlatformConnectOptionsRef,
3166 path: *const ::std::os::raw::c_char,
3167 );
3168 pub fn CreateSBPlatformShellCommand(
3169 shell_command: *const ::std::os::raw::c_char,
3170 ) -> SBPlatformShellCommandRef;
3171 pub fn CreateSBPlatformShellCommand2(
3172 shell: *const ::std::os::raw::c_char,
3173 shell_command: *const ::std::os::raw::c_char,
3174 ) -> SBPlatformShellCommandRef;
3175 pub fn CloneSBPlatformShellCommand(
3176 instance: SBPlatformShellCommandRef,
3177 ) -> SBPlatformShellCommandRef;
3178 pub fn DisposeSBPlatformShellCommand(instance: SBPlatformShellCommandRef);
3179 pub fn SBPlatformShellCommandClear(instance: SBPlatformShellCommandRef);
3180 pub fn SBPlatformShellCommandGetShell(
3181 instance: SBPlatformShellCommandRef,
3182 ) -> *const ::std::os::raw::c_char;
3183 pub fn SBPlatformShellCommandSetShell(
3184 instance: SBPlatformShellCommandRef,
3185 shell: *const ::std::os::raw::c_char,
3186 );
3187 pub fn SBPlatformShellCommandGetCommand(
3188 instance: SBPlatformShellCommandRef,
3189 ) -> *const ::std::os::raw::c_char;
3190 pub fn SBPlatformShellCommandSetCommand(
3191 instance: SBPlatformShellCommandRef,
3192 shell_command: *const ::std::os::raw::c_char,
3193 );
3194 pub fn SBPlatformShellCommandGetWorkingDirectory(
3195 instance: SBPlatformShellCommandRef,
3196 ) -> *const ::std::os::raw::c_char;
3197 pub fn SBPlatformShellCommandSetWorkingDirectory(
3198 instance: SBPlatformShellCommandRef,
3199 path: *const ::std::os::raw::c_char,
3200 );
3201 pub fn SBPlatformShellCommandGetTimeoutSeconds(instance: SBPlatformShellCommandRef) -> u32;
3202 pub fn SBPlatformShellCommandSetTimeoutSeconds(instance: SBPlatformShellCommandRef, sec: u32);
3203 pub fn SBPlatformShellCommandGetSignal(
3204 instance: SBPlatformShellCommandRef,
3205 ) -> ::std::os::raw::c_int;
3206 pub fn SBPlatformShellCommandGetStatus(
3207 instance: SBPlatformShellCommandRef,
3208 ) -> ::std::os::raw::c_int;
3209 pub fn SBPlatformShellCommandGetOutput(
3210 instance: SBPlatformShellCommandRef,
3211 ) -> *const ::std::os::raw::c_char;
3212 pub fn CreateSBPlatform() -> SBPlatformRef;
3213 pub fn CreateSBPlatform2(platform_name: *const ::std::os::raw::c_char) -> SBPlatformRef;
3214 pub fn CloneSBPlatform(instance: SBPlatformRef) -> SBPlatformRef;
3215 pub fn DisposeSBPlatform(instance: SBPlatformRef);
3216 pub fn SBPlatformGetHostPlatform() -> SBPlatformRef;
3217 pub fn SBPlatformIsValid(instance: SBPlatformRef) -> bool;
3218 pub fn SBPlatformClear(instance: SBPlatformRef);
3219 pub fn SBPlatformGetWorkingDirectory(instance: SBPlatformRef) -> *const ::std::os::raw::c_char;
3220 pub fn SBPlatformSetWorkingDirectory(
3221 instance: SBPlatformRef,
3222 path: *const ::std::os::raw::c_char,
3223 ) -> bool;
3224 pub fn SBPlatformGetName(instance: SBPlatformRef) -> *const ::std::os::raw::c_char;
3225 pub fn SBPlatformConnectRemote(
3226 instance: SBPlatformRef,
3227 connect_options: SBPlatformConnectOptionsRef,
3228 ) -> SBErrorRef;
3229 pub fn SBPlatformDisconnectRemote(instance: SBPlatformRef);
3230 pub fn SBPlatformIsConnected(instance: SBPlatformRef) -> bool;
3231 pub fn SBPlatformGetTriple(instance: SBPlatformRef) -> *const ::std::os::raw::c_char;
3232 pub fn SBPlatformGetHostname(instance: SBPlatformRef) -> *const ::std::os::raw::c_char;
3233 pub fn SBPlatformGetOSBuild(instance: SBPlatformRef) -> *const ::std::os::raw::c_char;
3234 pub fn SBPlatformGetOSDescription(instance: SBPlatformRef) -> *const ::std::os::raw::c_char;
3235 pub fn SBPlatformGetOSMajorVersion(instance: SBPlatformRef) -> u32;
3236 pub fn SBPlatformGetOSMinorVersion(instance: SBPlatformRef) -> u32;
3237 pub fn SBPlatformGetOSUpdateVersion(instance: SBPlatformRef) -> u32;
3238 pub fn SBPlatformSetSDKRoot(instance: SBPlatformRef, sysroot: *const ::std::os::raw::c_char);
3239 pub fn SBPlatformPut(
3240 instance: SBPlatformRef,
3241 src: SBFileSpecRef,
3242 dst: SBFileSpecRef,
3243 ) -> SBErrorRef;
3244 pub fn SBPlatformGet(
3245 instance: SBPlatformRef,
3246 src: SBFileSpecRef,
3247 dst: SBFileSpecRef,
3248 ) -> SBErrorRef;
3249 pub fn SBPlatformInstall(
3250 instance: SBPlatformRef,
3251 src: SBFileSpecRef,
3252 dst: SBFileSpecRef,
3253 ) -> SBErrorRef;
3254 pub fn SBPlatformRun(
3255 instance: SBPlatformRef,
3256 shell_command: SBPlatformShellCommandRef,
3257 ) -> SBErrorRef;
3258 pub fn SBPlatformLaunch(instance: SBPlatformRef, launch_info: SBLaunchInfoRef) -> SBErrorRef;
3259 pub fn SBPlatformKill(instance: SBPlatformRef, pid: lldb_pid_t) -> SBErrorRef;
3260 pub fn SBPlatformMakeDirectory(
3261 instance: SBPlatformRef,
3262 path: *const ::std::os::raw::c_char,
3263 file_permissions: u32,
3264 ) -> SBErrorRef;
3265 pub fn SBPlatformGetFilePermissions(
3266 instance: SBPlatformRef,
3267 path: *const ::std::os::raw::c_char,
3268 ) -> u32;
3269 pub fn SBPlatformSetFilePermissions(
3270 instance: SBPlatformRef,
3271 path: *const ::std::os::raw::c_char,
3272 file_permissions: u32,
3273 ) -> SBErrorRef;
3274 pub fn SBPlatformGetEnvironment(instance: SBPlatformRef) -> SBEnvironmentRef;
3275 pub fn CreateSBProcess() -> SBProcessRef;
3276 pub fn CloneSBProcess(instance: SBProcessRef) -> SBProcessRef;
3277 pub fn DisposeSBProcess(instance: SBProcessRef);
3278 pub fn SBProcessGetBroadcasterClassName() -> *const ::std::os::raw::c_char;
3279 pub fn SBProcessGetPluginName(instance: SBProcessRef) -> *const ::std::os::raw::c_char;
3280 pub fn SBProcessGetShortPluginName(instance: SBProcessRef) -> *const ::std::os::raw::c_char;
3281 pub fn SBProcessClear(instance: SBProcessRef);
3282 pub fn SBProcessIsValid(instance: SBProcessRef) -> bool;
3283 pub fn SBProcessGetTarget(instance: SBProcessRef) -> SBTargetRef;
3284 pub fn SBProcessGetByteOrder(instance: SBProcessRef) -> ByteOrder;
3285 pub fn SBProcessPutSTDIN(
3286 instance: SBProcessRef,
3287 src: *const ::std::os::raw::c_char,
3288 src_len: usize,
3289 ) -> usize;
3290 pub fn SBProcessGetSTDOUT(
3291 instance: SBProcessRef,
3292 dst: *mut ::std::os::raw::c_char,
3293 dst_len: usize,
3294 ) -> usize;
3295 pub fn SBProcessGetSTDERR(
3296 instance: SBProcessRef,
3297 dst: *mut ::std::os::raw::c_char,
3298 dst_len: usize,
3299 ) -> usize;
3300 pub fn SBProcessGetAsyncProfileData(
3301 instance: SBProcessRef,
3302 dst: *mut ::std::os::raw::c_char,
3303 dst_len: usize,
3304 ) -> usize;
3305 pub fn SBProcessReportEventState(instance: SBProcessRef, event: SBEventRef, out: SBFileRef);
3306 pub fn SBProcessAppendEventStateReport(
3307 instance: SBProcessRef,
3308 event: SBEventRef,
3309 result: SBCommandReturnObjectRef,
3310 );
3311 pub fn SBProcessRemoteAttachToProcessWithID(
3312 instance: SBProcessRef,
3313 pid: lldb_pid_t,
3314 error: SBErrorRef,
3315 ) -> bool;
3316 pub fn SBProcessRemoteLaunch(
3317 instance: SBProcessRef,
3318 argv: *const *const ::std::os::raw::c_char,
3319 envp: *const *const ::std::os::raw::c_char,
3320 stdin_path: *const ::std::os::raw::c_char,
3321 stdout_path: *const ::std::os::raw::c_char,
3322 stderr_path: *const ::std::os::raw::c_char,
3323 working_directory: *const ::std::os::raw::c_char,
3324 launch_flags: u32,
3325 stop_at_entry: bool,
3326 error: SBErrorRef,
3327 ) -> bool;
3328 pub fn SBProcessGetNumThreads(instance: SBProcessRef) -> u32;
3329 pub fn SBProcessGetThreadAtIndex(instance: SBProcessRef, index: usize) -> SBThreadRef;
3330 pub fn SBProcessGetThreadByID(instance: SBProcessRef, sb_thread_id: lldb_tid_t) -> SBThreadRef;
3331 pub fn SBProcessGetThreadByIndexID(instance: SBProcessRef, index_id: u32) -> SBThreadRef;
3332 pub fn SBProcessGetSelectedThread(instance: SBProcessRef) -> SBThreadRef;
3333 pub fn SBProcessCreateOSPluginThread(
3334 instance: SBProcessRef,
3335 tid: lldb_tid_t,
3336 context: lldb_addr_t,
3337 ) -> SBThreadRef;
3338 pub fn SBProcessSetSelectedThread(instance: SBProcessRef, thread: SBThreadRef) -> bool;
3339 pub fn SBProcessSetSelectedThreadByID(instance: SBProcessRef, tid: lldb_tid_t) -> bool;
3340 pub fn SBProcessSetSelectedThreadByIndexID(instance: SBProcessRef, index_id: u32) -> bool;
3341 pub fn SBProcessGetNumQueues(instance: SBProcessRef) -> u32;
3342 pub fn SBProcessGetQueueAtIndex(instance: SBProcessRef, index: usize) -> SBQueueRef;
3343 pub fn SBProcessGetState(instance: SBProcessRef) -> StateType;
3344 pub fn SBProcessGetExitStatus(instance: SBProcessRef) -> ::std::os::raw::c_int;
3345 pub fn SBProcessGetExitDescription(instance: SBProcessRef) -> *const ::std::os::raw::c_char;
3346 pub fn SBProcessGetProcessID(instance: SBProcessRef) -> lldb_pid_t;
3347 pub fn SBProcessGetUniqueID(instance: SBProcessRef) -> u32;
3348 pub fn SBProcessGetAddressByteSize(instance: SBProcessRef) -> u32;
3349 pub fn SBProcessDestroy(instance: SBProcessRef) -> SBErrorRef;
3350 pub fn SBProcessContinue(instance: SBProcessRef) -> SBErrorRef;
3351 pub fn SBProcessStop(instance: SBProcessRef) -> SBErrorRef;
3352 pub fn SBProcessKill(instance: SBProcessRef) -> SBErrorRef;
3353 pub fn SBProcessDetach(instance: SBProcessRef) -> SBErrorRef;
3354 pub fn SBProcessDetach2(instance: SBProcessRef, keep_stopped: bool) -> SBErrorRef;
3355 pub fn SBProcessSignal(instance: SBProcessRef, signal: ::std::os::raw::c_int) -> SBErrorRef;
3356 pub fn SBProcessGetUnixSignals(instance: SBProcessRef) -> SBUnixSignalsRef;
3357 pub fn SBProcessSendAsyncInterrupt(instance: SBProcessRef);
3358 pub fn SBProcessGetStopID(instance: SBProcessRef, include_expression_stops: bool) -> u32;
3359 pub fn SBProcessReadMemory(
3360 instance: SBProcessRef,
3361 addr: lldb_addr_t,
3362 buf: *mut ::std::os::raw::c_void,
3363 size: usize,
3364 error: SBErrorRef,
3365 ) -> usize;
3366 pub fn SBProcessWriteMemory(
3367 instance: SBProcessRef,
3368 addr: lldb_addr_t,
3369 buf: *mut ::std::os::raw::c_void,
3370 size: usize,
3371 error: SBErrorRef,
3372 ) -> usize;
3373 pub fn SBProcessReadCStringFromMemory(
3374 instance: SBProcessRef,
3375 addr: lldb_addr_t,
3376 buf: *mut ::std::os::raw::c_void,
3377 size: usize,
3378 error: SBErrorRef,
3379 ) -> usize;
3380 pub fn SBProcessReadUnsignedFromMemory(
3381 instance: SBProcessRef,
3382 addr: lldb_addr_t,
3383 byte_size: u32,
3384 error: SBErrorRef,
3385 ) -> u64;
3386 pub fn SBProcessReadPointerFromMemory(
3387 instance: SBProcessRef,
3388 addr: lldb_addr_t,
3389 error: SBErrorRef,
3390 ) -> lldb_addr_t;
3391 pub fn SBProcessGetStateFromEvent(event: SBEventRef) -> StateType;
3392 pub fn SBProcessGetRestartedFromEvent(event: SBEventRef) -> bool;
3393 pub fn SBProcessGetNumRestartedReasonsFromEvent(event: SBEventRef) -> usize;
3394 pub fn SBProcessGetRestartedReasonAtIndexFromEvent(
3395 event: SBEventRef,
3396 idx: usize,
3397 ) -> *const ::std::os::raw::c_char;
3398 pub fn SBProcessGetProcessFromEvent(event: SBEventRef) -> SBProcessRef;
3399 pub fn SBProcessGetInterruptedFromEvent(event: SBEventRef) -> bool;
3400 pub fn SBProcessGetStructuredDataFromEvent(event: SBEventRef) -> SBStructuredDataRef;
3401 pub fn SBProcessEventIsProcessEvent(event: SBEventRef) -> bool;
3402 pub fn SBProcessEventIsStructuredDataEvent(event: SBEventRef) -> bool;
3403 pub fn SBProcessGetBroadcaster(instance: SBProcessRef) -> SBBroadcasterRef;
3404 pub fn SBProcessGetBroadcasterClass() -> *const ::std::os::raw::c_char;
3405 pub fn SBProcessGetDescription(instance: SBProcessRef, description: SBStreamRef) -> bool;
3406 pub fn SBProcessGetExtendedCrashInformation(instance: SBProcessRef) -> SBStructuredDataRef;
3407 pub fn SBProcessGetNumSupportedHardwareWatchpoints(
3408 instance: SBProcessRef,
3409 error: SBErrorRef,
3410 ) -> u32;
3411 pub fn SBProcessLoadImage(
3412 instance: SBProcessRef,
3413 image_spec: SBFileSpecRef,
3414 error: SBErrorRef,
3415 ) -> u32;
3416 pub fn SBProcessLoadImageUsingPaths(
3417 instance: SBProcessRef,
3418 image_spec: SBFileSpecRef,
3419 paths: SBStringListRef,
3420 loaded_path: SBFileSpecRef,
3421 error: SBErrorRef,
3422 ) -> u32;
3423 pub fn SBProcessUnloadImage(instance: SBProcessRef, image_token: u32) -> SBErrorRef;
3424 pub fn SBProcessSendEventData(
3425 instance: SBProcessRef,
3426 data: *const ::std::os::raw::c_char,
3427 ) -> SBErrorRef;
3428 pub fn SBProcessGetNumExtendedBacktraceTypes(instance: SBProcessRef) -> u32;
3429 pub fn SBProcessGetExtendedBacktraceTypeAtIndex(
3430 instance: SBProcessRef,
3431 idx: u32,
3432 ) -> *const ::std::os::raw::c_char;
3433 pub fn SBProcessGetHistoryThreads(
3434 instance: SBProcessRef,
3435 addr: lldb_addr_t,
3436 ) -> SBThreadCollectionRef;
3437 pub fn SBProcessIsInstrumentationRuntimePresent(
3438 instance: SBProcessRef,
3439 type_: InstrumentationRuntimeType,
3440 ) -> bool;
3441 pub fn SBProcessSaveCore(
3442 instance: SBProcessRef,
3443 file_name: *const ::std::os::raw::c_char,
3444 ) -> SBErrorRef;
3445 pub fn SBProcessGetMemoryRegionInfo(
3446 instance: SBProcessRef,
3447 load_addr: lldb_addr_t,
3448 region_info: SBMemoryRegionInfoRef,
3449 ) -> SBErrorRef;
3450 pub fn SBProcessGetMemoryRegions(instance: SBProcessRef) -> SBMemoryRegionInfoListRef;
3451 pub fn SBProcessGetProcessInfo(instance: SBProcessRef) -> SBProcessInfoRef;
3452 pub fn SBProcessAllocateMemory(
3453 instance: SBProcessRef,
3454 size: usize,
3455 permissions: u32,
3456 error: SBErrorRef,
3457 ) -> lldb_addr_t;
3458 pub fn SBProcessDeallocateMemory(instance: SBProcessRef, ptr: lldb_addr_t) -> SBErrorRef;
3459 pub fn CreateSBProcessInfo() -> SBProcessInfoRef;
3460 pub fn CloneSBProcessInfo(instance: SBProcessInfoRef) -> SBProcessInfoRef;
3461 pub fn DisposeSBProcessInfo(instance: SBProcessInfoRef);
3462 pub fn SBProcessInfoIsValid(instance: SBProcessInfoRef) -> bool;
3463 pub fn SBProcessInfoGetName(instance: SBProcessInfoRef) -> *const ::std::os::raw::c_char;
3464 pub fn SBProcessInfoGetExecutableFile(instance: SBProcessInfoRef) -> SBFileSpecRef;
3465 pub fn SBProcessInfoGetProcessID(instance: SBProcessInfoRef) -> lldb_pid_t;
3466 pub fn SBProcessInfoGetUserID(instance: SBProcessInfoRef) -> u32;
3467 pub fn SBProcessInfoGetGroupID(instance: SBProcessInfoRef) -> u32;
3468 pub fn SBProcessInfoUserIDIsValid(instance: SBProcessInfoRef) -> bool;
3469 pub fn SBProcessInfoGroupIDIsValid(instance: SBProcessInfoRef) -> bool;
3470 pub fn SBProcessInfoGetEffectiveUserID(instance: SBProcessInfoRef) -> u32;
3471 pub fn SBProcessInfoGetEffectiveGroupID(instance: SBProcessInfoRef) -> u32;
3472 pub fn SBProcessInfoEffectiveUserIDIsValid(instance: SBProcessInfoRef) -> bool;
3473 pub fn SBProcessInfoEffectiveGroupIDIsValid(instance: SBProcessInfoRef) -> bool;
3474 pub fn SBProcessInfoGetParentProcessID(instance: SBProcessInfoRef) -> lldb_pid_t;
3475 pub fn SBProcessInfoGetTriple(instance: SBProcessInfoRef) -> *const ::std::os::raw::c_char;
3476 pub fn CreateSBQueue() -> SBQueueRef;
3477 pub fn CloneSBQueue(instance: SBQueueRef) -> SBQueueRef;
3478 pub fn DisposeSBQueue(instance: SBQueueRef);
3479 pub fn SBQueueIsValid(instance: SBQueueRef) -> bool;
3480 pub fn SBQueueClear(instance: SBQueueRef);
3481 pub fn SBQueueGetProcess(instance: SBQueueRef) -> SBProcessRef;
3482 pub fn SBQueueGetQueueID(instance: SBQueueRef) -> lldb_queue_id_t;
3483 pub fn SBQueueGetName(instance: SBQueueRef) -> *const ::std::os::raw::c_char;
3484 pub fn SBQueueGetIndexID(instance: SBQueueRef) -> u32;
3485 pub fn SBQueueGetNumThreads(instance: SBQueueRef) -> u32;
3486 pub fn SBQueueGetThreadAtIndex(instance: SBQueueRef, arg1: u32) -> SBThreadRef;
3487 pub fn SBQueueGetNumPendingItems(instance: SBQueueRef) -> u32;
3488 pub fn SBQueueGetPendingItemAtIndex(instance: SBQueueRef, arg1: u32) -> SBQueueItemRef;
3489 pub fn SBQueueGetNumRunningItems(instance: SBQueueRef) -> u32;
3490 pub fn SBQueueGetKind(instance: SBQueueRef) -> QueueKind;
3491 pub fn CreateSBQueueItem() -> SBQueueItemRef;
3492 pub fn CloneSBQueueItem(instance: SBQueueItemRef) -> SBQueueItemRef;
3493 pub fn DisposeSBQueueItem(instance: SBQueueItemRef);
3494 pub fn SBQueueItemIsValid(instance: SBQueueItemRef) -> bool;
3495 pub fn SBQueueItemClear(instance: SBQueueItemRef);
3496 pub fn SBQueueItemGetKind(instance: SBQueueItemRef) -> QueueItemKind;
3497 pub fn SBQueueItemSetKind(instance: SBQueueItemRef, kind: QueueItemKind);
3498 pub fn SBQueueItemGetAddress(instance: SBQueueItemRef) -> SBAddressRef;
3499 pub fn SBQueueItemSetAddress(instance: SBQueueItemRef, addr: SBAddressRef);
3500 pub fn SBQueueItemGetExtendedBacktraceThread(
3501 instance: SBQueueItemRef,
3502 type_: *const ::std::os::raw::c_char,
3503 ) -> SBThreadRef;
3504 pub fn CreateSBSection() -> SBSectionRef;
3505 pub fn CloneSBSection(instance: SBSectionRef) -> SBSectionRef;
3506 pub fn DisposeSBSection(instance: SBSectionRef);
3507 pub fn SBSectionIsValid(instance: SBSectionRef) -> bool;
3508 pub fn SBSectionGetName(instance: SBSectionRef) -> *const ::std::os::raw::c_char;
3509 pub fn SBSectionGetParent(instance: SBSectionRef) -> SBSectionRef;
3510 pub fn SBSectionFindSubSection(
3511 instance: SBSectionRef,
3512 sect_name: *const ::std::os::raw::c_char,
3513 ) -> SBSectionRef;
3514 pub fn SBSectionGetNumSubSections(instance: SBSectionRef) -> usize;
3515 pub fn SBSectionGetSubSectionAtIndex(instance: SBSectionRef, idx: usize) -> SBSectionRef;
3516 pub fn SBSectionGetFileAddress(instance: SBSectionRef) -> lldb_addr_t;
3517 pub fn SBSectionGetLoadAddress(instance: SBSectionRef, target: SBTargetRef) -> lldb_addr_t;
3518 pub fn SBSectionGetByteSize(instance: SBSectionRef) -> lldb_addr_t;
3519 pub fn SBSectionGetFileOffset(instance: SBSectionRef) -> u64;
3520 pub fn SBSectionGetFileByteSize(instance: SBSectionRef) -> u64;
3521 pub fn SBSectionGetSectionData(instance: SBSectionRef) -> SBDataRef;
3522 pub fn SBSectionGetSectionData2(instance: SBSectionRef, offset: u64, size: u64) -> SBDataRef;
3523 pub fn SBSectionGetSectionType(instance: SBSectionRef) -> SectionType;
3524 pub fn SBSectionGetPermissions(instance: SBSectionRef) -> u32;
3525 pub fn SBSectionGetTargetByteSize(instance: SBSectionRef) -> u32;
3526 pub fn SBSectionGetDescription(instance: SBSectionRef, description: SBStreamRef) -> bool;
3527 pub fn CreateSBSourceManager(debugger: SBDebuggerRef) -> SBSourceManagerRef;
3528 pub fn CreateSBSourceManager2(target: SBTargetRef) -> SBSourceManagerRef;
3529 pub fn CloneSBSourceManager(instance: SBSourceManagerRef) -> SBSourceManagerRef;
3530 pub fn DisposeSBSourceManager(instance: SBSourceManagerRef);
3531 pub fn SBSourceManagerDisplaySourceLinesWithLineNumbers(
3532 instance: SBSourceManagerRef,
3533 file: SBFileSpecRef,
3534 line: u32,
3535 context_before: u32,
3536 context_after: u32,
3537 current_line_cstr: *const ::std::os::raw::c_char,
3538 s: SBStreamRef,
3539 ) -> usize;
3540 pub fn SBSourceManagerDisplaySourceLinesWithLineNumbersAndColumn(
3541 instance: SBSourceManagerRef,
3542 file: SBFileSpecRef,
3543 line: u32,
3544 column: u32,
3545 context_before: u32,
3546 context_after: u32,
3547 current_line_cstr: *const ::std::os::raw::c_char,
3548 s: SBStreamRef,
3549 ) -> usize;
3550 pub fn CreateSBStream() -> SBStreamRef;
3551 pub fn DisposeSBStream(instance: SBStreamRef);
3552 pub fn SBStreamIsValid(instance: SBStreamRef) -> bool;
3553 pub fn SBStreamGetData(instance: SBStreamRef) -> *const ::std::os::raw::c_char;
3554 pub fn SBStreamGetSize(instance: SBStreamRef) -> usize;
3555 pub fn SBStreamPrintf(instance: SBStreamRef, format: *const ::std::os::raw::c_char, ...);
3556 pub fn SBStreamPrint(instance: SBStreamRef, str: *const ::std::os::raw::c_char);
3557 pub fn SBStreamRedirectToFile(
3558 instance: SBStreamRef,
3559 path: *const ::std::os::raw::c_char,
3560 append: bool,
3561 );
3562 pub fn SBStreamRedirectToFile2(instance: SBStreamRef, file: SBFileRef);
3563 pub fn SBStreamRedirectToFileHandle(
3564 instance: SBStreamRef,
3565 fh: *mut FILE,
3566 transfer_fh_ownership: bool,
3567 );
3568 pub fn SBStreamRedirectToFileDescriptor(
3569 instance: SBStreamRef,
3570 fd: ::std::os::raw::c_int,
3571 transfer_fh_ownership: bool,
3572 );
3573 pub fn SBStreamClear(instance: SBStreamRef);
3574 pub fn CreateSBStringList() -> SBStringListRef;
3575 pub fn CloneSBStringList(instance: SBStringListRef) -> SBStringListRef;
3576 pub fn DisposeSBStringList(instance: SBStringListRef);
3577 pub fn SBStringListIsValid(instance: SBStringListRef) -> bool;
3578 pub fn SBStringListAppendString(instance: SBStringListRef, str: *const ::std::os::raw::c_char);
3579 pub fn SBStringListAppendList(
3580 instance: SBStringListRef,
3581 strv: *const *const ::std::os::raw::c_char,
3582 strc: ::std::os::raw::c_int,
3583 );
3584 pub fn SBStringListAppendList2(instance: SBStringListRef, strings: SBStringListRef);
3585 pub fn SBStringListGetSize(instance: SBStringListRef) -> u32;
3586 pub fn SBStringListGetStringAtIndex(
3587 instance: SBStringListRef,
3588 idx: usize,
3589 ) -> *const ::std::os::raw::c_char;
3590 pub fn SBStringListClear(instance: SBStringListRef);
3591 pub fn CreateSBStructuredData() -> SBStructuredDataRef;
3592 pub fn CloneSBStructuredData(instance: SBStructuredDataRef) -> SBStructuredDataRef;
3593 pub fn DisposeSBStructuredData(instance: SBStructuredDataRef);
3594 pub fn SBStructuredDataIsValid(instance: SBStructuredDataRef) -> bool;
3595 pub fn SBStructuredDataClear(instance: SBStructuredDataRef);
3596 pub fn SBStructuredDataSetFromJSON(
3597 instance: SBStructuredDataRef,
3598 stream: SBStreamRef,
3599 ) -> SBErrorRef;
3600 pub fn SBStructuredDataSetFromJSON2(
3601 instance: SBStructuredDataRef,
3602 json: *const ::std::os::raw::c_char,
3603 ) -> SBErrorRef;
3604 pub fn SBStructuredDataGetAsJSON(
3605 instance: SBStructuredDataRef,
3606 stream: SBStreamRef,
3607 ) -> SBErrorRef;
3608 pub fn SBStructuredDataGetDescription(
3609 instance: SBStructuredDataRef,
3610 stream: SBStreamRef,
3611 ) -> SBErrorRef;
3612 pub fn SBStructuredDataGetType(instance: SBStructuredDataRef) -> StructuredDataType;
3613 pub fn SBStructuredDataGetSize(instance: SBStructuredDataRef) -> usize;
3614 pub fn SBStructuredDataGetKeys(instance: SBStructuredDataRef, keys: SBStringListRef) -> bool;
3615 pub fn SBStructuredDataGetValueForKey(
3616 instance: SBStructuredDataRef,
3617 key: *const ::std::os::raw::c_char,
3618 ) -> SBStructuredDataRef;
3619 pub fn SBStructuredDataGetItemAtIndex(
3620 instance: SBStructuredDataRef,
3621 idx: usize,
3622 ) -> SBStructuredDataRef;
3623 pub fn SBStructuredDataGetIntegerValue(instance: SBStructuredDataRef, fail_value: u64) -> u64;
3624 pub fn SBStructuredDataGetFloatValue(
3625 instance: SBStructuredDataRef,
3626 fail_value: ::std::os::raw::c_double,
3627 ) -> ::std::os::raw::c_double;
3628 pub fn SBStructuredDataGetBooleanValue(instance: SBStructuredDataRef, fail_value: bool)
3629 -> bool;
3630 pub fn SBStructuredDataGetStringValue(
3631 instance: SBStructuredDataRef,
3632 dst: *mut ::std::os::raw::c_char,
3633 dstlen: usize,
3634 ) -> usize;
3635 pub fn CreateSBSymbol() -> SBSymbolRef;
3636 pub fn CloneSBSymbol(instance: SBSymbolRef) -> SBSymbolRef;
3637 pub fn DisposeSBSymbol(instance: SBSymbolRef);
3638 pub fn SBSymbolIsValid(instance: SBSymbolRef) -> bool;
3639 pub fn SBSymbolGetName(instance: SBSymbolRef) -> *const ::std::os::raw::c_char;
3640 pub fn SBSymbolGetDisplayName(instance: SBSymbolRef) -> *const ::std::os::raw::c_char;
3641 pub fn SBSymbolGetMangledName(instance: SBSymbolRef) -> *const ::std::os::raw::c_char;
3642 pub fn SBSymbolGetInstructions(
3643 instance: SBSymbolRef,
3644 target: SBTargetRef,
3645 ) -> SBInstructionListRef;
3646 pub fn SBSymbolGetInstructions2(
3647 instance: SBSymbolRef,
3648 target: SBTargetRef,
3649 flavor_string: *const ::std::os::raw::c_char,
3650 ) -> SBInstructionListRef;
3651 pub fn SBSymbolGetStartAddress(instance: SBSymbolRef) -> SBAddressRef;
3652 pub fn SBSymbolGetEndAddress(instance: SBSymbolRef) -> SBAddressRef;
3653 pub fn SBSymbolGetPrologueByteSize(instance: SBSymbolRef) -> u32;
3654 pub fn SBSymbolGetType(instance: SBSymbolRef) -> SymbolType;
3655 pub fn SBSymbolGetDescription(instance: SBSymbolRef, description: SBStreamRef) -> bool;
3656 pub fn SBSymbolIsExternal(instance: SBSymbolRef) -> bool;
3657 pub fn SBSymbolIsSynthetic(instance: SBSymbolRef) -> bool;
3658 pub fn CreateSBSymbolContext() -> SBSymbolContextRef;
3659 pub fn CloneSBSymbolContext(instance: SBSymbolContextRef) -> SBSymbolContextRef;
3660 pub fn DisposeSBSymbolContext(instance: SBSymbolContextRef);
3661 pub fn SBSymbolContextIsValid(instance: SBSymbolContextRef) -> bool;
3662 pub fn SBSymbolContextGetModule(instance: SBSymbolContextRef) -> SBModuleRef;
3663 pub fn SBSymbolContextGetCompileUnit(instance: SBSymbolContextRef) -> SBCompileUnitRef;
3664 pub fn SBSymbolContextGetFunction(instance: SBSymbolContextRef) -> SBFunctionRef;
3665 pub fn SBSymbolContextGetBlock(instance: SBSymbolContextRef) -> SBBlockRef;
3666 pub fn SBSymbolContextGetLineEntry(instance: SBSymbolContextRef) -> SBLineEntryRef;
3667 pub fn SBSymbolContextGetSymbol(instance: SBSymbolContextRef) -> SBSymbolRef;
3668 pub fn SBSymbolContextSetModule(instance: SBSymbolContextRef, module: SBModuleRef);
3669 pub fn SBSymbolContextSetCompileUnit(
3670 instance: SBSymbolContextRef,
3671 compile_unit: SBCompileUnitRef,
3672 );
3673 pub fn SBSymbolContextSetFunction(instance: SBSymbolContextRef, function: SBFunctionRef);
3674 pub fn SBSymbolContextSetBlock(instance: SBSymbolContextRef, block: SBBlockRef);
3675 pub fn SBSymbolContextSetLineEntry(instance: SBSymbolContextRef, line_entry: SBLineEntryRef);
3676 pub fn SBSymbolContextSetSymbol(instance: SBSymbolContextRef, symbol: SBSymbolRef);
3677 pub fn SBSymbolContextGetParentOfInlinedScope(
3678 instance: SBSymbolContextRef,
3679 curr_frame_pc: SBAddressRef,
3680 parent_frame_addr: SBAddressRef,
3681 ) -> SBSymbolContextRef;
3682 pub fn SBSymbolContextGetDescription(
3683 instance: SBSymbolContextRef,
3684 description: SBStreamRef,
3685 ) -> bool;
3686 pub fn CreateSBSymbolContextList() -> SBSymbolContextListRef;
3687 pub fn CloneSBSymbolContextList(instance: SBSymbolContextListRef) -> SBSymbolContextListRef;
3688 pub fn DisposeSBSymbolContextList(instance: SBSymbolContextListRef);
3689 pub fn SBSymbolContextListIsValid(instance: SBSymbolContextListRef) -> bool;
3690 pub fn SBSymbolContextListGetSize(instance: SBSymbolContextListRef) -> u32;
3691 pub fn SBSymbolContextListGetContextAtIndex(
3692 instance: SBSymbolContextListRef,
3693 idx: u32,
3694 ) -> SBSymbolContextRef;
3695 pub fn SBSymbolContextListGetDescription(
3696 instance: SBSymbolContextListRef,
3697 description: SBStreamRef,
3698 ) -> bool;
3699 pub fn SBSymbolContextListAppend(instance: SBSymbolContextListRef, sc: SBSymbolContextRef);
3700 pub fn SBSymbolContextListAppendList(
3701 instance: SBSymbolContextListRef,
3702 sc_list: SBSymbolContextListRef,
3703 );
3704 pub fn SBSymbolContextListClear(instance: SBSymbolContextListRef);
3705 pub fn CreateSBTarget() -> SBTargetRef;
3706 pub fn CloneSBTarget(instance: SBTargetRef) -> SBTargetRef;
3707 pub fn DisposeSBTarget(instance: SBTargetRef);
3708 pub fn SBTargetIsValid(instance: SBTargetRef) -> bool;
3709 pub fn SBTargetEventIsTargetEvent(event: SBEventRef) -> bool;
3710 pub fn SBTargetGetTargetFromEvent(event: SBEventRef) -> SBTargetRef;
3711 pub fn SBTargetGetNumModulesFromEvent(event: SBEventRef) -> u32;
3712 pub fn SBTargetGetModuleAtIndexFromEvent(idx: u32, event: SBEventRef) -> SBModuleRef;
3713 pub fn SBTargetGetBroadcasterClassName() -> *const ::std::os::raw::c_char;
3714 pub fn SBTargetGetProcess(instance: SBTargetRef) -> SBProcessRef;
3715 pub fn SBTargetSetCollectingStats(instance: SBTargetRef, v: bool);
3716 pub fn SBTargetGetCollectingStats(instance: SBTargetRef) -> bool;
3717 pub fn SBTargetGetStatistics(instance: SBTargetRef) -> SBStructuredDataRef;
3718 pub fn SBTargetGetPlatform(instance: SBTargetRef) -> SBPlatformRef;
3719 pub fn SBTargetGetEnvironment(instance: SBTargetRef) -> SBEnvironmentRef;
3720 pub fn SBTargetInstall(instance: SBTargetRef) -> SBErrorRef;
3721 pub fn SBTargetLaunch(
3722 instance: SBTargetRef,
3723 listener: SBListenerRef,
3724 argv: *const *const ::std::os::raw::c_char,
3725 envp: *const *const ::std::os::raw::c_char,
3726 stdin_path: *const ::std::os::raw::c_char,
3727 stdout_path: *const ::std::os::raw::c_char,
3728 stderr_path: *const ::std::os::raw::c_char,
3729 working_directory: *const ::std::os::raw::c_char,
3730 launch_flags: u32,
3731 stop_at_entry: bool,
3732 error: SBErrorRef,
3733 ) -> SBProcessRef;
3734 pub fn SBTargetLaunchSimple(
3735 instance: SBTargetRef,
3736 argv: *const *const ::std::os::raw::c_char,
3737 envp: *const *const ::std::os::raw::c_char,
3738 working_directory: *const ::std::os::raw::c_char,
3739 ) -> SBProcessRef;
3740 pub fn SBTargetLaunch2(
3741 instance: SBTargetRef,
3742 launch_info: SBLaunchInfoRef,
3743 error: SBErrorRef,
3744 ) -> SBProcessRef;
3745 pub fn SBTargetLoadCore(
3746 instance: SBTargetRef,
3747 core_file: *const ::std::os::raw::c_char,
3748 error: SBErrorRef,
3749 ) -> SBProcessRef;
3750 pub fn SBTargetAttach(
3751 instance: SBTargetRef,
3752 attach_info: SBAttachInfoRef,
3753 error: SBErrorRef,
3754 ) -> SBProcessRef;
3755 pub fn SBTargetAttachToProcessWithID(
3756 instance: SBTargetRef,
3757 listener: SBListenerRef,
3758 pid: lldb_pid_t,
3759 error: SBErrorRef,
3760 ) -> SBProcessRef;
3761 pub fn SBTargetAttachToProcessWithName(
3762 instance: SBTargetRef,
3763 listener: SBListenerRef,
3764 name: *const ::std::os::raw::c_char,
3765 wait_for: bool,
3766 error: SBErrorRef,
3767 ) -> SBProcessRef;
3768 pub fn SBTargetConnectRemote(
3769 instance: SBTargetRef,
3770 listener: SBListenerRef,
3771 url: *const ::std::os::raw::c_char,
3772 plugin_name: *const ::std::os::raw::c_char,
3773 error: SBErrorRef,
3774 ) -> SBProcessRef;
3775 pub fn SBTargetGetExecutable(instance: SBTargetRef) -> SBFileSpecRef;
3776 pub fn SBTargetAppendImageSearchPath(
3777 instance: SBTargetRef,
3778 from: *const ::std::os::raw::c_char,
3779 to: *const ::std::os::raw::c_char,
3780 error: SBErrorRef,
3781 );
3782 pub fn SBTargetAddModule(instance: SBTargetRef, module: SBModuleRef) -> bool;
3783 pub fn SBTargetAddModuleSpec(
3784 instance: SBTargetRef,
3785 module_spec: SBModuleSpecRef,
3786 ) -> SBModuleRef;
3787 pub fn SBTargetGetNumModules(instance: SBTargetRef) -> u32;
3788 pub fn SBTargetGetModuleAtIndex(instance: SBTargetRef, idx: u32) -> SBModuleRef;
3789 pub fn SBTargetRemoveModule(instance: SBTargetRef, module: SBModuleRef) -> bool;
3790 pub fn SBTargetGetDebugger(instance: SBTargetRef) -> SBDebuggerRef;
3791 pub fn SBTargetFindModule(instance: SBTargetRef, file_spec: SBFileSpecRef) -> SBModuleRef;
3792 pub fn SBTargetFindCompileUnits(
3793 instance: SBTargetRef,
3794 file_spec: SBFileSpecRef,
3795 ) -> SBSymbolContextListRef;
3796 pub fn SBTargetGetByteOrder(instance: SBTargetRef) -> ByteOrder;
3797 pub fn SBTargetGetAddressByteSize(instance: SBTargetRef) -> u32;
3798 pub fn SBTargetGetTriple(instance: SBTargetRef) -> *const ::std::os::raw::c_char;
3799 pub fn SBTargetGetDataByteSize(instance: SBTargetRef) -> u32;
3800 pub fn SBTargetGetCodeByteSize(instance: SBTargetRef) -> u32;
3801 pub fn SBTargetGetMaximumNumberOfChildrenToDisplay(instance: SBTargetRef) -> u32;
3802 pub fn SBTargetSetSectionLoadAddress(
3803 instance: SBTargetRef,
3804 section: SBSectionRef,
3805 section_base_addr: lldb_addr_t,
3806 ) -> SBErrorRef;
3807 pub fn SBTargetClearSectionLoadAddress(
3808 instance: SBTargetRef,
3809 section: SBSectionRef,
3810 ) -> SBErrorRef;
3811 pub fn SBTargetSetModuleLoadAddress(
3812 instance: SBTargetRef,
3813 module: SBModuleRef,
3814 sections_offset: i64,
3815 ) -> SBErrorRef;
3816 pub fn SBTargetClearModuleLoadAddress(instance: SBTargetRef, module: SBModuleRef)
3817 -> SBErrorRef;
3818 pub fn SBTargetFindFunctions(
3819 instance: SBTargetRef,
3820 name: *const ::std::os::raw::c_char,
3821 name_type_mask: u32,
3822 ) -> SBSymbolContextListRef;
3823 pub fn SBTargetFindGlobalVariables(
3824 instance: SBTargetRef,
3825 name: *const ::std::os::raw::c_char,
3826 max_matches: u32,
3827 ) -> SBValueListRef;
3828 pub fn SBTargetFindFirstGlobalVariable(
3829 instance: SBTargetRef,
3830 name: *const ::std::os::raw::c_char,
3831 ) -> SBValueRef;
3832 pub fn SBTargetFindGlobalVariables2(
3833 instance: SBTargetRef,
3834 name: *const ::std::os::raw::c_char,
3835 max_matches: u32,
3836 matchtype: MatchType,
3837 ) -> SBValueListRef;
3838 pub fn SBTargetFindGlobalFunctions(
3839 instance: SBTargetRef,
3840 name: *const ::std::os::raw::c_char,
3841 max_matches: u32,
3842 matchtype: MatchType,
3843 ) -> SBSymbolContextListRef;
3844 pub fn SBTargetClear(instance: SBTargetRef);
3845 pub fn SBTargetResolveFileAddress(
3846 instance: SBTargetRef,
3847 file_addr: lldb_addr_t,
3848 ) -> SBAddressRef;
3849 pub fn SBTargetResolveLoadAddress(instance: SBTargetRef, vm_addr: lldb_addr_t) -> SBAddressRef;
3850 pub fn SBTargetResolvePastLoadAddress(
3851 instance: SBTargetRef,
3852 stop_id: u32,
3853 vm_addr: lldb_addr_t,
3854 ) -> SBAddressRef;
3855 pub fn SBTargetResolveSymbolContextForAddress(
3856 instance: SBTargetRef,
3857 addr: SBAddressRef,
3858 resolve_scope: u32,
3859 ) -> SBSymbolContextRef;
3860 pub fn SBTargetReadMemory(
3861 instance: SBTargetRef,
3862 addr: SBAddressRef,
3863 buf: *mut ::std::os::raw::c_void,
3864 size: usize,
3865 error: SBErrorRef,
3866 ) -> usize;
3867 pub fn SBTargetBreakpointCreateByLocation(
3868 instance: SBTargetRef,
3869 file: *const ::std::os::raw::c_char,
3870 line: u32,
3871 ) -> SBBreakpointRef;
3872 pub fn SBTargetBreakpointCreateByLocation2(
3873 instance: SBTargetRef,
3874 file_spec: SBFileSpecRef,
3875 line: u32,
3876 ) -> SBBreakpointRef;
3877 pub fn SBTargetBreakpointCreateByLocation3(
3878 instance: SBTargetRef,
3879 file_spec: SBFileSpecRef,
3880 line: u32,
3881 offset: lldb_addr_t,
3882 ) -> SBBreakpointRef;
3883 pub fn SBTargetBreakpointCreateByLocation4(
3884 instance: SBTargetRef,
3885 file_spec: SBFileSpecRef,
3886 line: u32,
3887 offset: lldb_addr_t,
3888 module_list: SBFileSpecListRef,
3889 ) -> SBBreakpointRef;
3890 pub fn SBTargetBreakpointCreateByLocation5(
3891 instance: SBTargetRef,
3892 file_spec: SBFileSpecRef,
3893 line: u32,
3894 column: u32,
3895 offset: lldb_addr_t,
3896 module_list: SBFileSpecListRef,
3897 ) -> SBBreakpointRef;
3898 pub fn SBTargetBreakpointCreateByLocation6(
3899 instance: SBTargetRef,
3900 file_spec: SBFileSpecRef,
3901 line: u32,
3902 column: u32,
3903 offset: lldb_addr_t,
3904 module_list: SBFileSpecListRef,
3905 move_to_nearest_code: bool,
3906 ) -> SBBreakpointRef;
3907 pub fn SBTargetBreakpointCreateByName(
3908 instance: SBTargetRef,
3909 symbol_name: *const ::std::os::raw::c_char,
3910 module_name: *const ::std::os::raw::c_char,
3911 ) -> SBBreakpointRef;
3912 pub fn SBTargetBreakpointCreateByName2(
3913 instance: SBTargetRef,
3914 symbol_name: *const ::std::os::raw::c_char,
3915 module_list: SBFileSpecListRef,
3916 comp_unit_list: SBFileSpecListRef,
3917 ) -> SBBreakpointRef;
3918 pub fn SBTargetBreakpointCreateByName3(
3919 instance: SBTargetRef,
3920 symbol_name: *const ::std::os::raw::c_char,
3921 name_type_mask: u32,
3922 module_list: SBFileSpecListRef,
3923 comp_unit_list: SBFileSpecListRef,
3924 ) -> SBBreakpointRef;
3925 pub fn SBTargetBreakpointCreateByNames(
3926 instance: SBTargetRef,
3927 symbol_name: *const *const ::std::os::raw::c_char,
3928 num_names: u32,
3929 name_type_mask: u32,
3930 module_list: SBFileSpecListRef,
3931 comp_unit_list: SBFileSpecListRef,
3932 ) -> SBBreakpointRef;
3933 pub fn SBTargetBreakpointCreateByNames2(
3934 instance: SBTargetRef,
3935 symbol_name: *const *const ::std::os::raw::c_char,
3936 num_names: u32,
3937 name_type_mask: u32,
3938 symbol_language: LanguageType,
3939 module_list: SBFileSpecListRef,
3940 comp_unit_list: SBFileSpecListRef,
3941 ) -> SBBreakpointRef;
3942 pub fn SBTargetBreakpointCreateByNames3(
3943 instance: SBTargetRef,
3944 symbol_name: *const *const ::std::os::raw::c_char,
3945 num_names: u32,
3946 name_type_mask: u32,
3947 symbol_language: LanguageType,
3948 offset: lldb_addr_t,
3949 module_list: SBFileSpecListRef,
3950 comp_unit_list: SBFileSpecListRef,
3951 ) -> SBBreakpointRef;
3952 pub fn SBTargetBreakpointCreateByRegex(
3953 instance: SBTargetRef,
3954 symbol_name_regex: *const ::std::os::raw::c_char,
3955 module_name: *const ::std::os::raw::c_char,
3956 ) -> SBBreakpointRef;
3957 pub fn SBTargetBreakpointCreateByRegex2(
3958 instance: SBTargetRef,
3959 symbol_name_regex: *const ::std::os::raw::c_char,
3960 module_list: SBFileSpecListRef,
3961 comp_unit_list: SBFileSpecListRef,
3962 ) -> SBBreakpointRef;
3963 pub fn SBTargetBreakpointCreateByRegex3(
3964 instance: SBTargetRef,
3965 symbol_name_regex: *const ::std::os::raw::c_char,
3966 symbol_language: LanguageType,
3967 module_list: SBFileSpecListRef,
3968 comp_unit_list: SBFileSpecListRef,
3969 ) -> SBBreakpointRef;
3970 pub fn SBTargetBreakpointCreateBySourceRegex(
3971 instance: SBTargetRef,
3972 source_regex: *const ::std::os::raw::c_char,
3973 source_file: SBFileSpecRef,
3974 module_name: *const ::std::os::raw::c_char,
3975 ) -> SBBreakpointRef;
3976 pub fn SBTargetBreakpointCreateBySourceRegex2(
3977 instance: SBTargetRef,
3978 source_regex: *const ::std::os::raw::c_char,
3979 module_list: SBFileSpecListRef,
3980 source_file: SBFileSpecListRef,
3981 ) -> SBBreakpointRef;
3982 pub fn SBTargetBreakpointCreateBySourceRegex3(
3983 instance: SBTargetRef,
3984 source_regex: *const ::std::os::raw::c_char,
3985 module_list: SBFileSpecListRef,
3986 source_file: SBFileSpecListRef,
3987 func_names: SBStringListRef,
3988 ) -> SBBreakpointRef;
3989 pub fn SBTargetBreakpointCreateForException(
3990 instance: SBTargetRef,
3991 language: LanguageType,
3992 catch_bp: bool,
3993 throw_bp: bool,
3994 ) -> SBBreakpointRef;
3995 pub fn SBTargetBreakpointCreateByAddress(
3996 instance: SBTargetRef,
3997 address: lldb_addr_t,
3998 ) -> SBBreakpointRef;
3999 pub fn SBTargetBreakpointCreateBySBAddress(
4000 instance: SBTargetRef,
4001 address: SBAddressRef,
4002 ) -> SBBreakpointRef;
4003 pub fn SBTargetBreakpointCreateFromScript(
4004 instance: SBTargetRef,
4005 class_name: *const ::std::os::raw::c_char,
4006 extra_args: SBStructuredDataRef,
4007 module_list: SBFileSpecListRef,
4008 file_list: SBFileSpecListRef,
4009 request_hardware: bool,
4010 ) -> SBBreakpointRef;
4011 pub fn SBTargetBreakpointsCreateFromFile(
4012 instance: SBTargetRef,
4013 source_file: SBFileSpecRef,
4014 new_bps: SBBreakpointListRef,
4015 ) -> SBErrorRef;
4016 pub fn SBTargetBreakpointsCreateFromFile2(
4017 instance: SBTargetRef,
4018 source_file: SBFileSpecRef,
4019 matching_names: SBStringListRef,
4020 new_bps: SBBreakpointListRef,
4021 ) -> SBErrorRef;
4022 pub fn SBTargetBreakpointsWriteToFile(
4023 instance: SBTargetRef,
4024 dest_file: SBFileSpecRef,
4025 ) -> SBErrorRef;
4026 pub fn SBTargetBreakpointsWriteToFile2(
4027 instance: SBTargetRef,
4028 dest_file: SBFileSpecRef,
4029 bkpt_list: SBBreakpointListRef,
4030 append: bool,
4031 ) -> SBErrorRef;
4032 pub fn SBTargetGetNumBreakpoints(instance: SBTargetRef) -> u32;
4033 pub fn SBTargetGetBreakpointAtIndex(instance: SBTargetRef, idx: u32) -> SBBreakpointRef;
4034 pub fn SBTargetBreakpointDelete(instance: SBTargetRef, break_id: lldb_break_id_t) -> bool;
4035 pub fn SBTargetFindBreakpointByID(
4036 instance: SBTargetRef,
4037 break_id: lldb_break_id_t,
4038 ) -> SBBreakpointRef;
4039 pub fn SBTargetFindBreakpointsByName(
4040 instance: SBTargetRef,
4041 name: *const ::std::os::raw::c_char,
4042 bkpt_list: SBBreakpointListRef,
4043 ) -> bool;
4044 pub fn SBTargetGetBreakpointNames(instance: SBTargetRef, names: SBStringListRef);
4045 pub fn SBTargetDeleteBreakpointName(instance: SBTargetRef, name: *const ::std::os::raw::c_char);
4046 pub fn SBTargetEnableAllBreakpoints(instance: SBTargetRef) -> bool;
4047 pub fn SBTargetDisableAllBreakpoints(instance: SBTargetRef) -> bool;
4048 pub fn SBTargetDeleteAllBreakpoints(instance: SBTargetRef) -> bool;
4049 pub fn SBTargetGetNumWatchpoints(instance: SBTargetRef) -> u32;
4050 pub fn SBTargetGetWatchpointAtIndex(instance: SBTargetRef, idx: u32) -> SBWatchpointRef;
4051 pub fn SBTargetDeleteWatchpoint(instance: SBTargetRef, watch_id: lldb_watch_id_t) -> bool;
4052 pub fn SBTargetFindWatchpointByID(
4053 instance: SBTargetRef,
4054 watch_id: lldb_watch_id_t,
4055 ) -> SBWatchpointRef;
4056 pub fn SBTargetWatchAddress(
4057 instance: SBTargetRef,
4058 addr: lldb_addr_t,
4059 size: usize,
4060 read: bool,
4061 write: bool,
4062 error: SBErrorRef,
4063 ) -> SBWatchpointRef;
4064 pub fn SBTargetEnableAllWatchpoints(instance: SBTargetRef) -> bool;
4065 pub fn SBTargetDisableAllWatchpoints(instance: SBTargetRef) -> bool;
4066 pub fn SBTargetDeleteAllWatchpoints(instance: SBTargetRef) -> bool;
4067 pub fn SBTargetGetBroadcaster(instance: SBTargetRef) -> SBBroadcasterRef;
4068 pub fn SBTargetFindFirstType(
4069 instance: SBTargetRef,
4070 type_: *const ::std::os::raw::c_char,
4071 ) -> SBTypeRef;
4072 pub fn SBTargetFindTypes(
4073 instance: SBTargetRef,
4074 type_: *const ::std::os::raw::c_char,
4075 ) -> SBTypeListRef;
4076 pub fn SBTargetGetBasicType(instance: SBTargetRef, type_: BasicType) -> SBTypeRef;
4077 pub fn SBTargetCreateValueFromAddress(
4078 instance: SBTargetRef,
4079 name: *const ::std::os::raw::c_char,
4080 addr: SBAddressRef,
4081 type_: SBTypeRef,
4082 ) -> SBValueRef;
4083 pub fn SBTargetCreateValueFromData(
4084 instance: SBTargetRef,
4085 name: *const ::std::os::raw::c_char,
4086 data: SBDataRef,
4087 type_: SBTypeRef,
4088 ) -> SBValueRef;
4089 pub fn SBTargetCreateValueFromExpression(
4090 instance: SBTargetRef,
4091 name: *const ::std::os::raw::c_char,
4092 expr: *const ::std::os::raw::c_char,
4093 ) -> SBValueRef;
4094 pub fn SBTargetGetSourceManager(instance: SBTargetRef) -> SBSourceManagerRef;
4095 pub fn SBTargetReadInstructions(
4096 instance: SBTargetRef,
4097 base_addr: SBAddressRef,
4098 count: u32,
4099 ) -> SBInstructionListRef;
4100 pub fn SBTargetReadInstructions2(
4101 instance: SBTargetRef,
4102 base_addr: SBAddressRef,
4103 count: u32,
4104 flavor_string: *const ::std::os::raw::c_char,
4105 ) -> SBInstructionListRef;
4106 pub fn SBTargetGetInstructions(
4107 instance: SBTargetRef,
4108 base_addr: SBAddressRef,
4109 buf: *mut ::std::os::raw::c_void,
4110 size: usize,
4111 ) -> SBInstructionListRef;
4112 pub fn SBTargetGetInstructionsWithFlavor(
4113 instance: SBTargetRef,
4114 base_addr: SBAddressRef,
4115 flavor_string: *const ::std::os::raw::c_char,
4116 buf: *mut ::std::os::raw::c_void,
4117 size: usize,
4118 ) -> SBInstructionListRef;
4119 pub fn SBTargetGetInstructions2(
4120 instance: SBTargetRef,
4121 base_addr: lldb_addr_t,
4122 buf: *mut ::std::os::raw::c_void,
4123 size: usize,
4124 ) -> SBInstructionListRef;
4125 pub fn SBTargetGetInstructionsWithFlavor2(
4126 instance: SBTargetRef,
4127 base_addr: lldb_addr_t,
4128 flavor_string: *const ::std::os::raw::c_char,
4129 buf: *mut ::std::os::raw::c_void,
4130 size: usize,
4131 ) -> SBInstructionListRef;
4132 pub fn SBTargetFindSymbols(
4133 instance: SBTargetRef,
4134 name: *const ::std::os::raw::c_char,
4135 type_: SymbolType,
4136 ) -> SBSymbolContextListRef;
4137 pub fn SBTargetGetDescription(
4138 instance: SBTargetRef,
4139 description: SBStreamRef,
4140 description_level: DescriptionLevel,
4141 ) -> bool;
4142 pub fn SBTargetEvaluateExpression(
4143 instance: SBTargetRef,
4144 expr: *const ::std::os::raw::c_char,
4145 options: SBExpressionOptionsRef,
4146 ) -> SBValueRef;
4147 pub fn SBTargetGetStackRedZoneSize(instance: SBTargetRef) -> lldb_addr_t;
4148 pub fn SBTargetIsLoaded(instance: SBTargetRef, module: SBModuleRef) -> bool;
4149 pub fn SBTargetGetLaunchInfo(instance: SBTargetRef) -> SBLaunchInfoRef;
4150 pub fn SBTargetSetLaunchInfo(instance: SBTargetRef, launch_info: SBLaunchInfoRef);
4151 pub fn SBThreadGetBroadcasterClassName() -> *const ::std::os::raw::c_char;
4152 pub fn CreateSBThread() -> SBThreadRef;
4153 pub fn CloneSBThread(instance: SBThreadRef) -> SBThreadRef;
4154 pub fn DisposeSBThread(instance: SBThreadRef);
4155 pub fn SBThreadGetQueue(instance: SBThreadRef) -> SBQueueRef;
4156 pub fn SBThreadIsValid(instance: SBThreadRef) -> bool;
4157 pub fn SBThreadClear(instance: SBThreadRef);
4158 pub fn SBThreadGetStopReason(instance: SBThreadRef) -> StopReason;
4159 pub fn SBThreadGetStopReasonDataCount(instance: SBThreadRef) -> usize;
4160 pub fn SBThreadGetStopReasonDataAtIndex(instance: SBThreadRef, idx: u32) -> u64;
4161 pub fn SBThreadGetStopReasonExtendedInfoAsJSON(
4162 instance: SBThreadRef,
4163 stream: SBStreamRef,
4164 ) -> bool;
4165 pub fn SBThreadGetStopReasonExtendedBacktraces(
4166 instance: SBThreadRef,
4167 type_: InstrumentationRuntimeType,
4168 ) -> SBThreadCollectionRef;
4169 pub fn SBThreadGetStopDescription(
4170 instance: SBThreadRef,
4171 dst: *mut ::std::os::raw::c_char,
4172 dst_len: usize,
4173 ) -> usize;
4174 pub fn SBThreadGetStopReturnValue(instance: SBThreadRef) -> SBValueRef;
4175 pub fn SBThreadGetThreadID(instance: SBThreadRef) -> lldb_tid_t;
4176 pub fn SBThreadGetIndexID(instance: SBThreadRef) -> u32;
4177 pub fn SBThreadGetName(instance: SBThreadRef) -> *const ::std::os::raw::c_char;
4178 pub fn SBThreadGetQueueName(instance: SBThreadRef) -> *const ::std::os::raw::c_char;
4179 pub fn SBThreadGetQueueID(instance: SBThreadRef) -> lldb_queue_id_t;
4180 pub fn SBThreadGetInfoItemByPathAsString(
4181 instance: SBThreadRef,
4182 path: *const ::std::os::raw::c_char,
4183 strm: SBStreamRef,
4184 ) -> bool;
4185 pub fn SBThreadStepOver(instance: SBThreadRef, stop_other_threads: RunMode, error: SBErrorRef);
4186 pub fn SBThreadStepInto(instance: SBThreadRef, stop_other_threads: RunMode);
4187 pub fn SBThreadStepInto2(
4188 instance: SBThreadRef,
4189 target_name: *const ::std::os::raw::c_char,
4190 stop_other_threads: RunMode,
4191 );
4192 pub fn SBThreadStepInto3(
4193 instance: SBThreadRef,
4194 target_name: *const ::std::os::raw::c_char,
4195 end_line: u32,
4196 error: SBErrorRef,
4197 stop_other_threads: RunMode,
4198 );
4199 pub fn SBThreadStepOut(instance: SBThreadRef, error: SBErrorRef);
4200 pub fn SBThreadStepOutOfFrame(instance: SBThreadRef, frame: SBFrameRef, error: SBErrorRef);
4201 pub fn SBThreadStepInstruction(instance: SBThreadRef, step_over: bool, error: SBErrorRef);
4202 pub fn SBThreadStepOverUntil(
4203 instance: SBThreadRef,
4204 frame: SBFrameRef,
4205 file_spec: SBFileSpecRef,
4206 line: u32,
4207 ) -> SBErrorRef;
4208 pub fn SBThreadStepUsingScriptedThreadPlan(
4209 instance: SBThreadRef,
4210 script_class_name: *const ::std::os::raw::c_char,
4211 args_data: SBStructuredDataRef,
4212 resume_immediately: bool,
4213 ) -> SBErrorRef;
4214 pub fn SBThreadJumpToLine(
4215 instance: SBThreadRef,
4216 file_spec: SBFileSpecRef,
4217 line: u32,
4218 ) -> SBErrorRef;
4219 pub fn SBThreadRunToAddress(instance: SBThreadRef, addr: lldb_addr_t, error: SBErrorRef);
4220 pub fn SBThreadReturnFromFrame(
4221 instance: SBThreadRef,
4222 frame: SBFrameRef,
4223 return_value: SBValueRef,
4224 ) -> SBErrorRef;
4225 pub fn SBThreadUnwindInnermostExpression(instance: SBThreadRef) -> SBErrorRef;
4226 pub fn SBThreadSuspend(instance: SBThreadRef, error: SBErrorRef) -> bool;
4227 pub fn SBThreadResume(instance: SBThreadRef, error: SBErrorRef) -> bool;
4228 pub fn SBThreadIsSuspended(instance: SBThreadRef) -> bool;
4229 pub fn SBThreadIsStopped(instance: SBThreadRef) -> bool;
4230 pub fn SBThreadGetNumFrames(instance: SBThreadRef) -> u32;
4231 pub fn SBThreadGetFrameAtIndex(instance: SBThreadRef, idx: u32) -> SBFrameRef;
4232 pub fn SBThreadGetSelectedFrame(instance: SBThreadRef) -> SBFrameRef;
4233 pub fn SBThreadSetSelectedFrame(instance: SBThreadRef, frame_idx: u32) -> SBFrameRef;
4234 pub fn SBThreadEventIsThreadEvent(event: SBEventRef) -> bool;
4235 pub fn SBThreadGetStackFrameFromEvent(event: SBEventRef) -> SBFrameRef;
4236 pub fn SBThreadGetThreadFromEvent(event: SBEventRef) -> SBThreadRef;
4237 pub fn SBThreadGetProcess(instance: SBThreadRef) -> SBProcessRef;
4238 pub fn SBThreadGetDescription(instance: SBThreadRef, description: SBStreamRef) -> bool;
4239 pub fn SBThreadGetStatus(instance: SBThreadRef, status: SBStreamRef) -> bool;
4240 pub fn SBThreadGetExtendedBacktraceThread(
4241 instance: SBThreadRef,
4242 type_: *const ::std::os::raw::c_char,
4243 ) -> SBThreadRef;
4244 pub fn SBThreadGetExtendedBacktraceOriginatingIndexID(instance: SBThreadRef) -> u32;
4245 pub fn SBThreadGetCurrentException(instance: SBThreadRef) -> SBValueRef;
4246 pub fn SBThreadGetCurrentExceptionBacktrace(instance: SBThreadRef) -> SBThreadRef;
4247 pub fn SBThreadSafeToCallFunctions(instance: SBThreadRef) -> bool;
4248 pub fn SBThreadGetSiginfo(instance: SBThreadRef) -> SBValueRef;
4249 pub fn CreateSBThreadCollection() -> SBThreadCollectionRef;
4250 pub fn CloneSBThreadCollection(instance: SBThreadCollectionRef) -> SBThreadCollectionRef;
4251 pub fn DisposeSBThreadCollection(instance: SBThreadCollectionRef);
4252 pub fn SBThreadCollectionIsValid(instance: SBThreadCollectionRef) -> bool;
4253 pub fn SBThreadCollectionGetSize(instance: SBThreadCollectionRef) -> usize;
4254 pub fn SBThreadCollectionGetThreadAtIndex(
4255 instance: SBThreadCollectionRef,
4256 idx: usize,
4257 ) -> SBThreadRef;
4258 pub fn CreateSBThreadPlan() -> SBThreadPlanRef;
4259 pub fn CreateSBThreadPlan2(
4260 thread: SBThreadRef,
4261 class_name: *const ::std::os::raw::c_char,
4262 args_data: SBStructuredDataRef,
4263 ) -> SBThreadPlanRef;
4264 pub fn CloneSBThreadPlan(instance: SBThreadPlanRef) -> SBThreadPlanRef;
4265 pub fn DisposeSBThreadPlan(instance: SBThreadPlanRef);
4266 pub fn SBThreadPlanIsValid(instance: SBThreadPlanRef) -> bool;
4267 pub fn SBThreadPlanClear(instance: SBThreadPlanRef);
4268 pub fn SBThreadPlanGetStopReason(instance: SBThreadPlanRef) -> StopReason;
4269 pub fn SBThreadPlanGetStopReasonDataCount(instance: SBThreadPlanRef) -> usize;
4270 pub fn SBThreadPlanGetStopReasonDataAtIndex(instance: SBThreadPlanRef, idx: u32) -> u64;
4271 pub fn SBThreadPlanGetThread(instance: SBThreadPlanRef) -> SBThreadRef;
4272 pub fn SBThreadPlanGetDescription(instance: SBThreadPlanRef, description: SBStreamRef) -> bool;
4273 pub fn SBThreadPlanSetPlanComplete(instance: SBThreadPlanRef, success: bool);
4274 pub fn SBThreadPlanIsPlanComplete(instance: SBThreadPlanRef) -> bool;
4275 pub fn SBThreadPlanIsPlanStale(instance: SBThreadPlanRef) -> bool;
4276 pub fn SBThreadPlanGetStopOthers(instance: SBThreadPlanRef) -> bool;
4277 pub fn SBThreadPlanSetStopOthers(instance: SBThreadPlanRef, stop_others: bool);
4278 pub fn SBThreadPlanQueueThreadPlanForStepOverRange(
4279 instance: SBThreadPlanRef,
4280 start_address: SBAddressRef,
4281 range_size: lldb_addr_t,
4282 error: SBErrorRef,
4283 ) -> SBThreadPlanRef;
4284 pub fn SBThreadPlanQueueThreadPlanForStepInRange(
4285 instance: SBThreadPlanRef,
4286 start_address: SBAddressRef,
4287 range_size: lldb_addr_t,
4288 error: SBErrorRef,
4289 ) -> SBThreadPlanRef;
4290 pub fn SBThreadPlanQueueThreadPlanForStepOut(
4291 instance: SBThreadPlanRef,
4292 frame_idx_to_step_to: u32,
4293 first_insn: bool,
4294 error: SBErrorRef,
4295 ) -> SBThreadPlanRef;
4296 pub fn SBThreadPlanQueueThreadPlanForRunToAddress(
4297 instance: SBThreadPlanRef,
4298 address: SBAddressRef,
4299 error: SBErrorRef,
4300 ) -> SBThreadPlanRef;
4301 pub fn SBThreadPlanQueueThreadPlanForStepScripted(
4302 instance: SBThreadPlanRef,
4303 script_class_name: *const ::std::os::raw::c_char,
4304 args_data: SBStructuredDataRef,
4305 error: SBErrorRef,
4306 ) -> SBThreadPlanRef;
4307 pub fn CreateSBTypeMember() -> SBTypeMemberRef;
4308 pub fn CloneSBTypeMember(instance: SBTypeMemberRef) -> SBTypeMemberRef;
4309 pub fn DisposeSBTypeMember(instance: SBTypeMemberRef);
4310 pub fn SBTypeMemberIsValid(instance: SBTypeMemberRef) -> bool;
4311 pub fn SBTypeMemberGetName(instance: SBTypeMemberRef) -> *const ::std::os::raw::c_char;
4312 pub fn SBTypeMemberGetType(instance: SBTypeMemberRef) -> SBTypeRef;
4313 pub fn SBTypeMemberGetOffsetInBytes(instance: SBTypeMemberRef) -> u64;
4314 pub fn SBTypeMemberGetOffsetInBits(instance: SBTypeMemberRef) -> u64;
4315 pub fn SBTypeMemberIsBitfield(instance: SBTypeMemberRef) -> bool;
4316 pub fn SBTypeMemberGetBitfieldSizeInBits(instance: SBTypeMemberRef) -> u32;
4317 pub fn SBTypeMemberGetDescription(
4318 instance: SBTypeMemberRef,
4319 description: SBStreamRef,
4320 description_level: DescriptionLevel,
4321 ) -> bool;
4322 pub fn CreateSBTypeMemberFunction() -> SBTypeMemberFunctionRef;
4323 pub fn CloneSBTypeMemberFunction(instance: SBTypeMemberFunctionRef) -> SBTypeMemberFunctionRef;
4324 pub fn DisposeSBTypeMemberFunction(instance: SBTypeMemberFunctionRef);
4325 pub fn SBTypeMemberFunctionIsValid(instance: SBTypeMemberFunctionRef) -> bool;
4326 pub fn SBTypeMemberFunctionGetName(
4327 instance: SBTypeMemberFunctionRef,
4328 ) -> *const ::std::os::raw::c_char;
4329 pub fn SBTypeMemberFunctionGetType(instance: SBTypeMemberFunctionRef) -> SBTypeRef;
4330 pub fn SBTypeMemberFunctionGetReturnType(instance: SBTypeMemberFunctionRef) -> SBTypeRef;
4331 pub fn SBTypeMemberFunctionGetNumberOfArguments(instance: SBTypeMemberFunctionRef) -> u32;
4332 pub fn SBTypeMemberFunctionGetArgumentTypeAtIndex(
4333 instance: SBTypeMemberFunctionRef,
4334 arg1: u32,
4335 ) -> SBTypeRef;
4336 pub fn SBTypeMemberFunctionGetKind(instance: SBTypeMemberFunctionRef) -> MemberFunctionKind;
4337 pub fn SBTypeMemberFunctionGetDescription(
4338 instance: SBTypeMemberFunctionRef,
4339 description: SBStreamRef,
4340 description_level: DescriptionLevel,
4341 ) -> bool;
4342 pub fn CreateSBType() -> SBTypeRef;
4343 pub fn CloneSBType(instance: SBTypeRef) -> SBTypeRef;
4344 pub fn DisposeSBType(instance: SBTypeRef);
4345 pub fn SBTypeIsValid(instance: SBTypeRef) -> bool;
4346 pub fn SBTypeGetByteSize(instance: SBTypeRef) -> u64;
4347 pub fn SBTypeIsPointerType(instance: SBTypeRef) -> bool;
4348 pub fn SBTypeIsReferenceType(instance: SBTypeRef) -> bool;
4349 pub fn SBTypeIsFunctionType(instance: SBTypeRef) -> bool;
4350 pub fn SBTypeIsPolymorphicClass(instance: SBTypeRef) -> bool;
4351 pub fn SBTypeIsArrayType(instance: SBTypeRef) -> bool;
4352 pub fn SBTypeIsVectorType(instance: SBTypeRef) -> bool;
4353 pub fn SBTypeIsTypedefType(instance: SBTypeRef) -> bool;
4354 pub fn SBTypeIsAnonymousType(instance: SBTypeRef) -> bool;
4355 pub fn SBTypeIsScopedEnumerationType(instance: SBTypeRef) -> bool;
4356 pub fn SBTypeGetPointerType(instance: SBTypeRef) -> SBTypeRef;
4357 pub fn SBTypeGetPointeeType(instance: SBTypeRef) -> SBTypeRef;
4358 pub fn SBTypeGetReferenceType(instance: SBTypeRef) -> SBTypeRef;
4359 pub fn SBTypeGetTypedefedType(instance: SBTypeRef) -> SBTypeRef;
4360 pub fn SBTypeGetDereferencedType(instance: SBTypeRef) -> SBTypeRef;
4361 pub fn SBTypeGetUnqualifiedType(instance: SBTypeRef) -> SBTypeRef;
4362 pub fn SBTypeGetArrayElementType(instance: SBTypeRef) -> SBTypeRef;
4363 pub fn SBTypeGetArrayType(instance: SBTypeRef, size: u64) -> SBTypeRef;
4364 pub fn SBTypeGetVectorElementType(instance: SBTypeRef) -> SBTypeRef;
4365 pub fn SBTypeGetCanonicalType(instance: SBTypeRef) -> SBTypeRef;
4366 pub fn SBTypeGetEnumerationIntegerType(instance: SBTypeRef) -> SBTypeRef;
4367 pub fn SBTypeGetBasicType(instance: SBTypeRef) -> BasicType;
4368 pub fn SBTypeGetBasicType2(instance: SBTypeRef, type_: BasicType) -> SBTypeRef;
4369 pub fn SBTypeGetNumberOfFields(instance: SBTypeRef) -> u32;
4370 pub fn SBTypeGetNumberOfDirectBaseClasses(instance: SBTypeRef) -> u32;
4371 pub fn SBTypeGetNumberOfVirtualBaseClasses(instance: SBTypeRef) -> u32;
4372 pub fn SBTypeGetFieldAtIndex(instance: SBTypeRef, idx: u32) -> SBTypeMemberRef;
4373 pub fn SBTypeGetDirectBaseClassAtIndex(instance: SBTypeRef, idx: u32) -> SBTypeMemberRef;
4374 pub fn SBTypeGetVirtualBaseClassAtIndex(instance: SBTypeRef, idx: u32) -> SBTypeMemberRef;
4375 pub fn SBTypeGetEnumMembers(instance: SBTypeRef) -> SBTypeEnumMemberListRef;
4376 pub fn SBTypeGetNumberOfTemplateArguments(instance: SBTypeRef) -> u32;
4377 pub fn SBTypeGetTemplateArgumentType(instance: SBTypeRef, idx: u32) -> SBTypeRef;
4378 pub fn SBTypeGetTemplateArgumentKind(instance: SBTypeRef, idx: u32) -> TemplateArgumentKind;
4379 pub fn SBTypeGetFunctionReturnType(instance: SBTypeRef) -> SBTypeRef;
4380 pub fn SBTypeGetFunctionArgumentTypes(instance: SBTypeRef) -> SBTypeListRef;
4381 pub fn SBTypeGetNumberOfMemberFunctions(instance: SBTypeRef) -> u32;
4382 pub fn SBTypeGetMemberFunctionAtIndex(instance: SBTypeRef, idx: u32)
4383 -> SBTypeMemberFunctionRef;
4384 pub fn SBTypeGetModule(instance: SBTypeRef) -> SBModuleRef;
4385 pub fn SBTypeGetName(instance: SBTypeRef) -> *const ::std::os::raw::c_char;
4386 pub fn SBTypeGetDisplayTypeName(instance: SBTypeRef) -> *const ::std::os::raw::c_char;
4387 pub fn SBTypeGetTypeClass(instance: SBTypeRef) -> u32;
4388 pub fn SBTypeIsTypeComplete(instance: SBTypeRef) -> bool;
4389 pub fn SBTypeGetTypeFlags(instance: SBTypeRef) -> u32;
4390 pub fn SBTypeGetDescription(
4391 instance: SBTypeRef,
4392 description: SBStreamRef,
4393 description_level: DescriptionLevel,
4394 ) -> bool;
4395 pub fn CreateSBTypeList() -> SBTypeListRef;
4396 pub fn CloneSBTypeList(instance: SBTypeListRef) -> SBTypeListRef;
4397 pub fn DisposeSBTypeList(instance: SBTypeListRef);
4398 pub fn SBTypeListIsValid(instance: SBTypeListRef) -> bool;
4399 pub fn SBTypeListAppend(instance: SBTypeListRef, type_: SBTypeRef);
4400 pub fn SBTypeListGetTypeAtIndex(instance: SBTypeListRef, index: u32) -> SBTypeRef;
4401 pub fn SBTypeListGetSize(instance: SBTypeListRef) -> u32;
4402 pub fn CreateSBTypeCategory() -> SBTypeCategoryRef;
4403 pub fn CloneSBTypeCategory(instance: SBTypeCategoryRef) -> SBTypeCategoryRef;
4404 pub fn DisposeSBTypeCategory(instance: SBTypeCategoryRef);
4405 pub fn SBTypeCategoryIsValid(instance: SBTypeCategoryRef) -> bool;
4406 pub fn SBTypeCategoryGetEnabled(instance: SBTypeCategoryRef) -> bool;
4407 pub fn SBTypeCategorySetEnabled(instance: SBTypeCategoryRef, arg1: bool);
4408 pub fn SBTypeCategoryGetName(instance: SBTypeCategoryRef) -> *const ::std::os::raw::c_char;
4409 pub fn SBTypeCategoryGetLanguageAtIndex(
4410 instance: SBTypeCategoryRef,
4411 index: u32,
4412 ) -> LanguageType;
4413 pub fn SBTypeCategoryGetNumLanguages(instance: SBTypeCategoryRef) -> u32;
4414 pub fn SBTypeCategoryAddLanguage(instance: SBTypeCategoryRef, language: LanguageType);
4415 pub fn SBTypeCategoryGetDescription(
4416 instance: SBTypeCategoryRef,
4417 description: SBStreamRef,
4418 description_level: DescriptionLevel,
4419 ) -> bool;
4420 pub fn SBTypeCategoryGetNumFormats(instance: SBTypeCategoryRef) -> u32;
4421 pub fn SBTypeCategoryGetNumSummaries(instance: SBTypeCategoryRef) -> u32;
4422 pub fn SBTypeCategoryGetNumFilters(instance: SBTypeCategoryRef) -> u32;
4423 pub fn SBTypeCategoryGetNumSynthetics(instance: SBTypeCategoryRef) -> u32;
4424 pub fn SBTypeCategoryGetTypeNameSpecifierForFilterAtIndex(
4425 instance: SBTypeCategoryRef,
4426 arg1: u32,
4427 ) -> SBTypeNameSpecifierRef;
4428 pub fn SBTypeCategoryGetTypeNameSpecifierForFormatAtIndex(
4429 instance: SBTypeCategoryRef,
4430 arg1: u32,
4431 ) -> SBTypeNameSpecifierRef;
4432 pub fn SBTypeCategoryGetTypeNameSpecifierForSummaryAtIndex(
4433 instance: SBTypeCategoryRef,
4434 arg1: u32,
4435 ) -> SBTypeNameSpecifierRef;
4436 pub fn SBTypeCategoryGetTypeNameSpecifierForSyntheticAtIndex(
4437 instance: SBTypeCategoryRef,
4438 arg1: u32,
4439 ) -> SBTypeNameSpecifierRef;
4440 pub fn SBTypeCategoryGetFilterForType(
4441 instance: SBTypeCategoryRef,
4442 arg1: SBTypeNameSpecifierRef,
4443 ) -> SBTypeFilterRef;
4444 pub fn SBTypeCategoryGetFormatForType(
4445 instance: SBTypeCategoryRef,
4446 arg1: SBTypeNameSpecifierRef,
4447 ) -> SBTypeFormatRef;
4448 pub fn SBTypeCategoryGetSummaryForType(
4449 instance: SBTypeCategoryRef,
4450 arg1: SBTypeNameSpecifierRef,
4451 ) -> SBTypeSummaryRef;
4452 pub fn SBTypeCategoryGetSyntheticForType(
4453 instance: SBTypeCategoryRef,
4454 arg1: SBTypeNameSpecifierRef,
4455 ) -> SBTypeSyntheticRef;
4456 pub fn SBTypeCategoryGetFilterAtIndex(
4457 instance: SBTypeCategoryRef,
4458 arg1: u32,
4459 ) -> SBTypeFilterRef;
4460 pub fn SBTypeCategoryGetFormatAtIndex(
4461 instance: SBTypeCategoryRef,
4462 arg1: u32,
4463 ) -> SBTypeFormatRef;
4464 pub fn SBTypeCategoryGetSummaryAtIndex(
4465 instance: SBTypeCategoryRef,
4466 arg1: u32,
4467 ) -> SBTypeSummaryRef;
4468 pub fn SBTypeCategoryGetSyntheticAtIndex(
4469 instance: SBTypeCategoryRef,
4470 arg1: u32,
4471 ) -> SBTypeSyntheticRef;
4472 pub fn SBTypeCategoryAddTypeFormat(
4473 instance: SBTypeCategoryRef,
4474 arg1: SBTypeNameSpecifierRef,
4475 arg2: SBTypeFormatRef,
4476 ) -> bool;
4477 pub fn SBTypeCategoryDeleteTypeFormat(
4478 instance: SBTypeCategoryRef,
4479 arg1: SBTypeNameSpecifierRef,
4480 ) -> bool;
4481 pub fn SBTypeCategoryAddTypeSummary(
4482 instance: SBTypeCategoryRef,
4483 arg1: SBTypeNameSpecifierRef,
4484 arg2: SBTypeSummaryRef,
4485 ) -> bool;
4486 pub fn SBTypeCategoryDeleteTypeSummary(
4487 instance: SBTypeCategoryRef,
4488 arg1: SBTypeNameSpecifierRef,
4489 ) -> bool;
4490 pub fn SBTypeCategoryAddTypeFilter(
4491 instance: SBTypeCategoryRef,
4492 arg1: SBTypeNameSpecifierRef,
4493 arg2: SBTypeFilterRef,
4494 ) -> bool;
4495 pub fn SBTypeCategoryDeleteTypeFilter(
4496 instance: SBTypeCategoryRef,
4497 arg1: SBTypeNameSpecifierRef,
4498 ) -> bool;
4499 pub fn SBTypeCategoryAddTypeSynthetic(
4500 instance: SBTypeCategoryRef,
4501 arg1: SBTypeNameSpecifierRef,
4502 arg2: SBTypeSyntheticRef,
4503 ) -> bool;
4504 pub fn SBTypeCategoryDeleteTypeSynthetic(
4505 instance: SBTypeCategoryRef,
4506 arg1: SBTypeNameSpecifierRef,
4507 ) -> bool;
4508 pub fn CreateSBTypeEnumMember() -> SBTypeEnumMemberRef;
4509 pub fn CloneSBTypeEnumMember(instance: SBTypeEnumMemberRef) -> SBTypeEnumMemberRef;
4510 pub fn DisposeSBTypeEnumMember(instance: SBTypeEnumMemberRef);
4511 pub fn SBTypeEnumMemberIsValid(instance: SBTypeEnumMemberRef) -> bool;
4512 pub fn SBTypeEnumMemberGetValueAsSigned(instance: SBTypeEnumMemberRef) -> i64;
4513 pub fn SBTypeEnumMemberGetValueAsUnsigned(instance: SBTypeEnumMemberRef) -> u64;
4514 pub fn SBTypeEnumMemberGetName(instance: SBTypeEnumMemberRef) -> *const ::std::os::raw::c_char;
4515 pub fn SBTypeEnumMemberGetType(instance: SBTypeEnumMemberRef) -> SBTypeRef;
4516 pub fn SBTypeEnumMemberGetDescription(
4517 instance: SBTypeEnumMemberRef,
4518 description: SBStreamRef,
4519 description_level: DescriptionLevel,
4520 ) -> bool;
4521 pub fn CreateSBTypeEnumMemberList() -> SBTypeEnumMemberListRef;
4522 pub fn CloneSBTypeEnumMemberList(instance: SBTypeEnumMemberListRef) -> SBTypeEnumMemberListRef;
4523 pub fn DisposeSBTypeEnumMemberList(instance: SBTypeEnumMemberListRef);
4524 pub fn SBTypeEnumMemberListIsValid(instance: SBTypeEnumMemberListRef) -> bool;
4525 pub fn SBTypeEnumMemberListAppend(
4526 instance: SBTypeEnumMemberListRef,
4527 entry: SBTypeEnumMemberRef,
4528 );
4529 pub fn SBTypeEnumMemberListGetTypeEnumMemberAtIndex(
4530 instance: SBTypeEnumMemberListRef,
4531 index: u32,
4532 ) -> SBTypeEnumMemberRef;
4533 pub fn SBTypeEnumMemberListGetSize(instance: SBTypeEnumMemberListRef) -> u32;
4534 pub fn CreateSBTypeFilter() -> SBTypeFilterRef;
4535 pub fn CreateSBTypeFilter2(options: u32) -> SBTypeFilterRef;
4536 pub fn CloneSBTypeFilter(instance: SBTypeFilterRef) -> SBTypeFilterRef;
4537 pub fn DisposeSBTypeFilter(instance: SBTypeFilterRef);
4538 pub fn SBTypeFilterIsValid(instance: SBTypeFilterRef) -> bool;
4539 pub fn SBTypeFilterGetNumberOfExpressionPaths(instance: SBTypeFilterRef) -> u32;
4540 pub fn SBTypeFilterGetExpressionPathAtIndex(
4541 instance: SBTypeFilterRef,
4542 i: u32,
4543 ) -> *const ::std::os::raw::c_char;
4544 pub fn SBTypeFilterReplaceExpressionPathAtIndex(
4545 instance: SBTypeFilterRef,
4546 i: u32,
4547 item: *const ::std::os::raw::c_char,
4548 ) -> bool;
4549 pub fn SBTypeFilterAppendExpressionPath(
4550 instance: SBTypeFilterRef,
4551 item: *const ::std::os::raw::c_char,
4552 );
4553 pub fn SBTypeFilterClear(instance: SBTypeFilterRef);
4554 pub fn SBTypeFilterGetOptions(instance: SBTypeFilterRef) -> u32;
4555 pub fn SBTypeFilterSetOptions(instance: SBTypeFilterRef, arg1: u32);
4556 pub fn SBTypeFilterGetDescription(
4557 instance: SBTypeFilterRef,
4558 description: SBStreamRef,
4559 description_level: DescriptionLevel,
4560 ) -> bool;
4561 pub fn SBTypeFilterIsEqualTo(instance: SBTypeFilterRef, rhs: SBTypeFilterRef) -> bool;
4562 pub fn CreateSBTypeFormat() -> SBTypeFormatRef;
4563 pub fn CreateSBTypeFormat2(format: Format, options: u32) -> SBTypeFormatRef;
4564 pub fn CreateSBTypeFormat3(
4565 type_: *const ::std::os::raw::c_char,
4566 options: u32,
4567 ) -> SBTypeFormatRef;
4568 pub fn CloneSBTypeFormat(instance: SBTypeFormatRef) -> SBTypeFormatRef;
4569 pub fn DisposeSBTypeFormat(instance: SBTypeFormatRef);
4570 pub fn SBTypeFormatIsValid(instance: SBTypeFormatRef) -> bool;
4571 pub fn SBTypeFormatGetFormat(instance: SBTypeFormatRef) -> Format;
4572 pub fn SBTypeFormatGetTypeName(instance: SBTypeFormatRef) -> *const ::std::os::raw::c_char;
4573 pub fn SBTypeFormatGetOptions(instance: SBTypeFormatRef) -> u32;
4574 pub fn SBTypeFormatSetFormat(instance: SBTypeFormatRef, arg1: Format);
4575 pub fn SBTypeFormatSetTypeName(instance: SBTypeFormatRef, arg1: *const ::std::os::raw::c_char);
4576 pub fn SBTypeFormatSetOptions(instance: SBTypeFormatRef, arg1: u32);
4577 pub fn SBTypeFormatGetDescription(
4578 instance: SBTypeFormatRef,
4579 description: SBStreamRef,
4580 description_level: DescriptionLevel,
4581 ) -> bool;
4582 pub fn SBTypeFormatIsEqualTo(instance: SBTypeFormatRef, rhs: SBTypeFormatRef) -> bool;
4583 pub fn CreateSBTypeNameSpecifier() -> SBTypeNameSpecifierRef;
4584 pub fn CreateSBTypeNameSpecifier2(
4585 name: *const ::std::os::raw::c_char,
4586 is_regex: bool,
4587 ) -> SBTypeNameSpecifierRef;
4588 pub fn CreateSBTypeNameSpecifier3(type_: SBTypeRef) -> SBTypeNameSpecifierRef;
4589 pub fn CloneSBTypeNameSpecifier(instance: SBTypeNameSpecifierRef) -> SBTypeNameSpecifierRef;
4590 pub fn DisposeSBTypeNameSpecifier(instance: SBTypeNameSpecifierRef);
4591 pub fn SBTypeNameSpecifierIsValid(instance: SBTypeNameSpecifierRef) -> bool;
4592 pub fn SBTypeNameSpecifierGetName(
4593 instance: SBTypeNameSpecifierRef,
4594 ) -> *const ::std::os::raw::c_char;
4595 pub fn SBTypeNameSpecifierGetType(instance: SBTypeNameSpecifierRef) -> SBTypeRef;
4596 pub fn SBTypeNameSpecifierIsRegex(instance: SBTypeNameSpecifierRef) -> bool;
4597 pub fn SBTypeNameSpecifierGetDescription(
4598 instance: SBTypeNameSpecifierRef,
4599 description: SBStreamRef,
4600 description_level: DescriptionLevel,
4601 ) -> bool;
4602 pub fn SBTypeNameSpecifierIsEqualTo(
4603 instance: SBTypeNameSpecifierRef,
4604 rhs: SBTypeNameSpecifierRef,
4605 ) -> bool;
4606 pub fn CreateSBTypeSummaryOptions() -> SBTypeSummaryOptionsRef;
4607 pub fn CloneSBTypeSummaryOptions(instance: SBTypeSummaryOptionsRef) -> SBTypeSummaryOptionsRef;
4608 pub fn DisposeSBTypeSummaryOptions(instance: SBTypeSummaryOptionsRef);
4609 pub fn SBTypeSummaryOptionsIsValid(instance: SBTypeSummaryOptionsRef) -> bool;
4610 pub fn SBTypeSummaryOptionsGetLanguage(instance: SBTypeSummaryOptionsRef) -> LanguageType;
4611 pub fn SBTypeSummaryOptionsGetCapping(instance: SBTypeSummaryOptionsRef) -> TypeSummaryCapping;
4612 pub fn SBTypeSummaryOptionsSetLanguage(instance: SBTypeSummaryOptionsRef, arg1: LanguageType);
4613 pub fn SBTypeSummaryOptionsSetCapping(
4614 instance: SBTypeSummaryOptionsRef,
4615 arg1: TypeSummaryCapping,
4616 );
4617 pub fn CreateSBTypeSummary() -> SBTypeSummaryRef;
4618 pub fn SBTypeSummaryCreateWithSummaryString(
4619 data: *const ::std::os::raw::c_char,
4620 options: u32,
4621 ) -> SBTypeSummaryRef;
4622 pub fn SBTypeSummaryCreateWithFunctionName(
4623 data: *const ::std::os::raw::c_char,
4624 options: u32,
4625 ) -> SBTypeSummaryRef;
4626 pub fn SBTypeSummaryCreateWithScriptCode(
4627 data: *const ::std::os::raw::c_char,
4628 options: u32,
4629 ) -> SBTypeSummaryRef;
4630 pub fn CloneSBTypeSummary(instance: SBTypeSummaryRef) -> SBTypeSummaryRef;
4631 pub fn DisposeSBTypeSummary(instance: SBTypeSummaryRef);
4632 pub fn SBTypeSummaryIsValid(instance: SBTypeSummaryRef) -> bool;
4633 pub fn SBTypeSummaryIsFunctionCode(instance: SBTypeSummaryRef) -> bool;
4634 pub fn SBTypeSummaryIsFunctionName(instance: SBTypeSummaryRef) -> bool;
4635 pub fn SBTypeSummaryIsSummaryString(instance: SBTypeSummaryRef) -> bool;
4636 pub fn SBTypeSummaryGetData(instance: SBTypeSummaryRef) -> *const ::std::os::raw::c_char;
4637 pub fn SBTypeSummarySetSummaryString(
4638 instance: SBTypeSummaryRef,
4639 data: *const ::std::os::raw::c_char,
4640 );
4641 pub fn SBTypeSummarySetFunctionName(
4642 instance: SBTypeSummaryRef,
4643 data: *const ::std::os::raw::c_char,
4644 );
4645 pub fn SBTypeSummarySetFunctionCode(
4646 instance: SBTypeSummaryRef,
4647 data: *const ::std::os::raw::c_char,
4648 );
4649 pub fn SBTypeSummaryGetOptions(instance: SBTypeSummaryRef) -> u32;
4650 pub fn SBTypeSummarySetOptions(instance: SBTypeSummaryRef, arg1: u32);
4651 pub fn SBTypeSummaryGetDescription(
4652 instance: SBTypeSummaryRef,
4653 description: SBStreamRef,
4654 description_level: DescriptionLevel,
4655 ) -> bool;
4656 pub fn SBTypeSummaryIsEqualTo(instance: SBTypeSummaryRef, rhs: SBTypeSummaryRef) -> bool;
4657 pub fn CreateSBTypeSynthetic() -> SBTypeSyntheticRef;
4658 pub fn SBTypeSyntheticCreateWithClassName(
4659 data: *const ::std::os::raw::c_char,
4660 options: u32,
4661 ) -> SBTypeSyntheticRef;
4662 pub fn SBTypeSyntheticCreateWithScriptCode(
4663 data: *const ::std::os::raw::c_char,
4664 options: u32,
4665 ) -> SBTypeSyntheticRef;
4666 pub fn CloneSBTypeSynthetic(instance: SBTypeSyntheticRef) -> SBTypeSyntheticRef;
4667 pub fn DisposeSBTypeSynthetic(instance: SBTypeSyntheticRef);
4668 pub fn SBTypeSyntheticIsValid(instance: SBTypeSyntheticRef) -> bool;
4669 pub fn SBTypeSyntheticIsClassCode(instance: SBTypeSyntheticRef) -> bool;
4670 pub fn SBTypeSyntheticIsClassName(instance: SBTypeSyntheticRef) -> bool;
4671 pub fn SBTypeSyntheticGetData(instance: SBTypeSyntheticRef) -> *const ::std::os::raw::c_char;
4672 pub fn SBTypeSyntheticSetClassName(
4673 instance: SBTypeSyntheticRef,
4674 data: *const ::std::os::raw::c_char,
4675 );
4676 pub fn SBTypeSyntheticSetClassCode(
4677 instance: SBTypeSyntheticRef,
4678 data: *const ::std::os::raw::c_char,
4679 );
4680 pub fn SBTypeSyntheticGetOptions(instance: SBTypeSyntheticRef) -> u32;
4681 pub fn SBTypeSyntheticSetOptions(instance: SBTypeSyntheticRef, arg1: u32);
4682 pub fn SBTypeSyntheticGetDescription(
4683 instance: SBTypeSyntheticRef,
4684 description: SBStreamRef,
4685 description_level: DescriptionLevel,
4686 ) -> bool;
4687 pub fn SBTypeSyntheticIsEqualTo(instance: SBTypeSyntheticRef, rhs: SBTypeSyntheticRef) -> bool;
4688 pub fn CreateSBUnixSignals() -> SBUnixSignalsRef;
4689 pub fn CloneSBUnixSignals(instance: SBUnixSignalsRef) -> SBUnixSignalsRef;
4690 pub fn DisposeSBUnixSignals(instance: SBUnixSignalsRef);
4691 pub fn SBUnixSignalsClear(instance: SBUnixSignalsRef);
4692 pub fn SBUnixSignalsIsValid(instance: SBUnixSignalsRef) -> bool;
4693 pub fn SBUnixSignalsGetSignalAsCString(
4694 instance: SBUnixSignalsRef,
4695 signo: i32,
4696 ) -> *const ::std::os::raw::c_char;
4697 pub fn SBUnixSignalsGetSignalNumberFromName(
4698 instance: SBUnixSignalsRef,
4699 name: *const ::std::os::raw::c_char,
4700 ) -> i32;
4701 pub fn SBUnixSignalsGetShouldSuppress(instance: SBUnixSignalsRef, signo: i32) -> bool;
4702 pub fn SBUnixSignalsSetShouldSuppress(
4703 instance: SBUnixSignalsRef,
4704 signo: i32,
4705 value: bool,
4706 ) -> bool;
4707 pub fn SBUnixSignalsGetShouldStop(instance: SBUnixSignalsRef, signo: i32) -> bool;
4708 pub fn SBUnixSignalsSetShouldStop(instance: SBUnixSignalsRef, signo: i32, value: bool) -> bool;
4709 pub fn SBUnixSignalsGetShouldNotify(instance: SBUnixSignalsRef, signo: i32) -> bool;
4710 pub fn SBUnixSignalsSetShouldNotify(
4711 instance: SBUnixSignalsRef,
4712 signo: i32,
4713 value: bool,
4714 ) -> bool;
4715 pub fn SBUnixSignalsGetNumSignals(instance: SBUnixSignalsRef) -> i32;
4716 pub fn SBUnixSignalsGetSignalAtIndex(instance: SBUnixSignalsRef, index: i32) -> i32;
4717 pub fn CreateSBValue() -> SBValueRef;
4718 pub fn CloneSBValue(instance: SBValueRef) -> SBValueRef;
4719 pub fn DisposeSBValue(instance: SBValueRef);
4720 pub fn SBValueIsValid(instance: SBValueRef) -> bool;
4721 pub fn SBValueClear(instance: SBValueRef);
4722 pub fn SBValueGetError(instance: SBValueRef) -> SBErrorRef;
4723 pub fn SBValueGetID(instance: SBValueRef) -> lldb_user_id_t;
4724 pub fn SBValueGetName(instance: SBValueRef) -> *const ::std::os::raw::c_char;
4725 pub fn SBValueGetTypeName(instance: SBValueRef) -> *const ::std::os::raw::c_char;
4726 pub fn SBValueGetDisplayTypeName(instance: SBValueRef) -> *const ::std::os::raw::c_char;
4727 pub fn SBValueGetByteSize(instance: SBValueRef) -> usize;
4728 pub fn SBValueIsInScope(instance: SBValueRef) -> bool;
4729 pub fn SBValueGetFormat(instance: SBValueRef) -> Format;
4730 pub fn SBValueSetFormat(instance: SBValueRef, format: Format);
4731 pub fn SBValueGetValue(instance: SBValueRef) -> *const ::std::os::raw::c_char;
4732 pub fn SBValueGetValueAsSigned(instance: SBValueRef, error: SBErrorRef, fail_value: i64)
4733 -> i64;
4734 pub fn SBValueGetValueAsUnsigned(
4735 instance: SBValueRef,
4736 error: SBErrorRef,
4737 fail_value: u64,
4738 ) -> u64;
4739 pub fn SBValueGetValueAsSigned2(instance: SBValueRef, fail_value: i64) -> i64;
4740 pub fn SBValueGetValueAsUnsigned2(instance: SBValueRef, fail_value: u64) -> u64;
4741 pub fn SBValueGetValueType(instance: SBValueRef) -> ValueType;
4742 pub fn SBValueGetValueDidChange(instance: SBValueRef) -> bool;
4743 pub fn SBValueGetSummary(instance: SBValueRef) -> *const ::std::os::raw::c_char;
4744 pub fn SBValueGetSummary2(
4745 instance: SBValueRef,
4746 stream: SBStreamRef,
4747 options: SBTypeSummaryOptionsRef,
4748 ) -> *const ::std::os::raw::c_char;
4749 pub fn SBValueGetObjectDescription(instance: SBValueRef) -> *const ::std::os::raw::c_char;
4750 pub fn SBValueGetDynamicValue(
4751 instance: SBValueRef,
4752 use_dynamic: DynamicValueType,
4753 ) -> SBValueRef;
4754 pub fn SBValueGetStaticValue(instance: SBValueRef) -> SBValueRef;
4755 pub fn SBValueGetNonSyntheticValue(instance: SBValueRef) -> SBValueRef;
4756 pub fn SBValueGetPreferDynamicValue(instance: SBValueRef) -> DynamicValueType;
4757 pub fn SBValueSetPreferDynamicValue(instance: SBValueRef, use_dynamic: DynamicValueType);
4758 pub fn SBValueGetPreferSyntheticValue(instance: SBValueRef) -> bool;
4759 pub fn SBValueSetPreferSyntheticValue(instance: SBValueRef, use_synthetic: bool);
4760 pub fn SBValueIsDynamic(instance: SBValueRef) -> bool;
4761 pub fn SBValueIsSynthetic(instance: SBValueRef) -> bool;
4762 pub fn SBValueIsSyntheticChildrenGenerated(instance: SBValueRef) -> bool;
4763 pub fn SBValueSetSyntheticChildrenGenerated(instance: SBValueRef, b: bool);
4764 pub fn SBValueGetLocation(instance: SBValueRef) -> *const ::std::os::raw::c_char;
4765 pub fn SBValueSetValueFromCString(
4766 instance: SBValueRef,
4767 value_str: *const ::std::os::raw::c_char,
4768 ) -> bool;
4769 pub fn SBValueSetValueFromCString2(
4770 instance: SBValueRef,
4771 value_str: *const ::std::os::raw::c_char,
4772 error: SBErrorRef,
4773 ) -> bool;
4774 pub fn SBValueGetTypeFormat(instance: SBValueRef) -> SBTypeFormatRef;
4775 pub fn SBValueGetTypeSummary(instance: SBValueRef) -> SBTypeSummaryRef;
4776 pub fn SBValueGetTypeFilter(instance: SBValueRef) -> SBTypeFilterRef;
4777 pub fn SBValueGetTypeSynthetic(instance: SBValueRef) -> SBTypeSyntheticRef;
4778 pub fn SBValueGetChildAtIndex(instance: SBValueRef, idx: u32) -> SBValueRef;
4779 pub fn SBValueCreateChildAtOffset(
4780 instance: SBValueRef,
4781 name: *const ::std::os::raw::c_char,
4782 offset: u32,
4783 type_: SBTypeRef,
4784 ) -> SBValueRef;
4785 pub fn SBValueCast(instance: SBValueRef, type_: SBTypeRef) -> SBValueRef;
4786 pub fn SBValueCreateValueFromExpression(
4787 instance: SBValueRef,
4788 name: *const ::std::os::raw::c_char,
4789 expression: *const ::std::os::raw::c_char,
4790 ) -> SBValueRef;
4791 pub fn SBValueCreateValueFromExpression2(
4792 instance: SBValueRef,
4793 name: *const ::std::os::raw::c_char,
4794 expression: *const ::std::os::raw::c_char,
4795 options: SBExpressionOptionsRef,
4796 ) -> SBValueRef;
4797 pub fn SBValueCreateValueFromAddress(
4798 instance: SBValueRef,
4799 name: *const ::std::os::raw::c_char,
4800 address: lldb_addr_t,
4801 type_: SBTypeRef,
4802 ) -> SBValueRef;
4803 pub fn SBValueCreateValueFromData(
4804 instance: SBValueRef,
4805 name: *const ::std::os::raw::c_char,
4806 data: SBDataRef,
4807 type_: SBTypeRef,
4808 ) -> SBValueRef;
4809 pub fn SBValueGetChildAtIndex2(
4810 instance: SBValueRef,
4811 idx: u32,
4812 use_dynamic: DynamicValueType,
4813 can_create_synthetic: bool,
4814 ) -> SBValueRef;
4815 pub fn SBValueGetIndexOfChildWithName(
4816 instance: SBValueRef,
4817 name: *const ::std::os::raw::c_char,
4818 ) -> u32;
4819 pub fn SBValueGetChildMemberWithName(
4820 instance: SBValueRef,
4821 name: *const ::std::os::raw::c_char,
4822 ) -> SBValueRef;
4823 pub fn SBValueGetChildMemberWithName2(
4824 instance: SBValueRef,
4825 name: *const ::std::os::raw::c_char,
4826 use_dynamic: DynamicValueType,
4827 ) -> SBValueRef;
4828 pub fn SBValueGetValueForExpressionPath(
4829 instance: SBValueRef,
4830 expr_path: *const ::std::os::raw::c_char,
4831 ) -> SBValueRef;
4832 pub fn SBValueAddressOf(instance: SBValueRef) -> SBValueRef;
4833 pub fn SBValueGetLoadAddress(instance: SBValueRef) -> lldb_addr_t;
4834 pub fn SBValueGetAddress(instance: SBValueRef) -> SBAddressRef;
4835 pub fn SBValueGetPointeeData(instance: SBValueRef, item_idx: u32, item_count: u32)
4836 -> SBDataRef;
4837 pub fn SBValueGetData(instance: SBValueRef) -> SBDataRef;
4838 pub fn SBValueSetData(instance: SBValueRef, data: SBDataRef, error: SBErrorRef) -> bool;
4839 pub fn SBValueClone(
4840 instance: SBValueRef,
4841 new_name: *const ::std::os::raw::c_char,
4842 ) -> SBValueRef;
4843 pub fn SBValueGetDeclaration(instance: SBValueRef) -> SBDeclarationRef;
4844 pub fn SBValueMightHaveChildren(instance: SBValueRef) -> bool;
4845 pub fn SBValueIsRuntimeSupportValue(instance: SBValueRef) -> bool;
4846 pub fn SBValueGetNumChildren(instance: SBValueRef) -> u32;
4847 pub fn SBValueGetOpaqueType(instance: SBValueRef) -> *mut ::std::os::raw::c_void;
4848 pub fn SBValueGetTarget(instance: SBValueRef) -> SBTargetRef;
4849 pub fn SBValueGetProcess(instance: SBValueRef) -> SBProcessRef;
4850 pub fn SBValueGetThread(instance: SBValueRef) -> SBThreadRef;
4851 pub fn SBValueGetFrame(instance: SBValueRef) -> SBFrameRef;
4852 pub fn SBValueDereference(instance: SBValueRef) -> SBValueRef;
4853 pub fn SBValueTypeIsPointerType(instance: SBValueRef) -> bool;
4854 pub fn SBValueGetType(instance: SBValueRef) -> SBTypeRef;
4855 pub fn SBValuePersist(instance: SBValueRef) -> SBValueRef;
4856 pub fn SBValueGetDescription(instance: SBValueRef, description: SBStreamRef) -> bool;
4857 pub fn SBValueGetExpressionPath(instance: SBValueRef, description: SBStreamRef) -> bool;
4858 pub fn SBValueGetExpressionPath2(
4859 instance: SBValueRef,
4860 description: SBStreamRef,
4861 qualify_cxx_base_classes: bool,
4862 ) -> bool;
4863 pub fn SBValueEvaluateExpression(
4864 instance: SBValueRef,
4865 expr: *const ::std::os::raw::c_char,
4866 options: SBExpressionOptionsRef,
4867 name: *const ::std::os::raw::c_char,
4868 ) -> SBValueRef;
4869 pub fn SBValueWatch(
4870 instance: SBValueRef,
4871 resolve_location: bool,
4872 read: bool,
4873 write: bool,
4874 error: SBErrorRef,
4875 ) -> SBWatchpointRef;
4876 pub fn SBValueWatch2(
4877 instance: SBValueRef,
4878 resolve_location: bool,
4879 read: bool,
4880 write: bool,
4881 ) -> SBWatchpointRef;
4882 pub fn SBValueWatchPointee(
4883 instance: SBValueRef,
4884 resolve_location: bool,
4885 read: bool,
4886 write: bool,
4887 error: SBErrorRef,
4888 ) -> SBWatchpointRef;
4889 pub fn CreateSBValueList() -> SBValueListRef;
4890 pub fn CloneSBValueList(instance: SBValueListRef) -> SBValueListRef;
4891 pub fn DisposeSBValueList(instance: SBValueListRef);
4892 pub fn SBValueListIsValid(instance: SBValueListRef) -> bool;
4893 pub fn SBValueListClear(instance: SBValueListRef);
4894 pub fn SBValueListAppend(instance: SBValueListRef, val_obj: SBValueRef);
4895 pub fn SBValueListAppendList(instance: SBValueListRef, value_list: SBValueListRef);
4896 pub fn SBValueListGetSize(instance: SBValueListRef) -> u32;
4897 pub fn SBValueListGetValueAtIndex(instance: SBValueListRef, idx: u32) -> SBValueRef;
4898 pub fn SBValueListGetFirstValueByName(
4899 instance: SBValueListRef,
4900 name: *const ::std::os::raw::c_char,
4901 ) -> SBValueRef;
4902 pub fn SBValueListFindValueObjectByUID(
4903 instance: SBValueListRef,
4904 uid: lldb_user_id_t,
4905 ) -> SBValueRef;
4906 pub fn CreateSBVariablesOptions() -> SBVariablesOptionsRef;
4907 pub fn CloneSBVariablesOptions(instance: SBVariablesOptionsRef) -> SBVariablesOptionsRef;
4908 pub fn DisposeSBVariablesOptions(instance: SBVariablesOptionsRef);
4909 pub fn SBVariablesOptionsIsValid(instance: SBVariablesOptionsRef) -> bool;
4910 pub fn SBVariablesOptionsGetIncludeArguments(instance: SBVariablesOptionsRef) -> bool;
4911 pub fn SBVariablesOptionsSetIncludeArguments(instance: SBVariablesOptionsRef, arg1: bool);
4912 pub fn SBVariablesOptionsGetIncludeRecognizedArguments(
4913 instance: SBVariablesOptionsRef,
4914 target: SBTargetRef,
4915 ) -> bool;
4916 pub fn SBVariablesOptionsSetIncludeRecognizedArguments(
4917 instance: SBVariablesOptionsRef,
4918 arg1: bool,
4919 );
4920 pub fn SBVariablesOptionsGetIncludeLocals(instance: SBVariablesOptionsRef) -> bool;
4921 pub fn SBVariablesOptionsSetIncludeLocals(instance: SBVariablesOptionsRef, arg1: bool);
4922 pub fn SBVariablesOptionsGetIncludeStatics(instance: SBVariablesOptionsRef) -> bool;
4923 pub fn SBVariablesOptionsSetIncludeStatics(instance: SBVariablesOptionsRef, arg1: bool);
4924 pub fn SBVariablesOptionsGetInScopeOnly(instance: SBVariablesOptionsRef) -> bool;
4925 pub fn SBVariablesOptionsSetInScopeOnly(instance: SBVariablesOptionsRef, arg1: bool);
4926 pub fn SBVariablesOptionsGetIncludeRuntimeSupportValues(
4927 instance: SBVariablesOptionsRef,
4928 ) -> bool;
4929 pub fn SBVariablesOptionsSetIncludeRuntimeSupportValues(
4930 instance: SBVariablesOptionsRef,
4931 arg1: bool,
4932 );
4933 pub fn SBVariablesOptionsGetUseDynamic(instance: SBVariablesOptionsRef) -> DynamicValueType;
4934 pub fn SBVariablesOptionsSetUseDynamic(instance: SBVariablesOptionsRef, arg1: DynamicValueType);
4935 pub fn CreateSBWatchpoint() -> SBWatchpointRef;
4936 pub fn CloneSBWatchpoint(instance: SBWatchpointRef) -> SBWatchpointRef;
4937 pub fn DisposeSBWatchpoint(instance: SBWatchpointRef);
4938 pub fn SBWatchpointIsValid(instance: SBWatchpointRef) -> bool;
4939 pub fn SBWatchpointGetError(instance: SBWatchpointRef) -> SBErrorRef;
4940 pub fn SBWatchpointGetID(instance: SBWatchpointRef) -> lldb_watch_id_t;
4941 pub fn SBWatchpointGetHardwareIndex(instance: SBWatchpointRef) -> i32;
4942 pub fn SBWatchpointGetWatchAddress(instance: SBWatchpointRef) -> lldb_addr_t;
4943 pub fn SBWatchpointGetWatchSize(instance: SBWatchpointRef) -> usize;
4944 pub fn SBWatchpointSetEnabled(instance: SBWatchpointRef, enabled: bool);
4945 pub fn SBWatchpointIsEnabled(instance: SBWatchpointRef) -> bool;
4946 pub fn SBWatchpointGetHitCount(instance: SBWatchpointRef) -> u32;
4947 pub fn SBWatchpointGetIgnoreCount(instance: SBWatchpointRef) -> u32;
4948 pub fn SBWatchpointSetIgnoreCount(instance: SBWatchpointRef, n: u32);
4949 pub fn SBWatchpointGetCondition(instance: SBWatchpointRef) -> *const ::std::os::raw::c_char;
4950 pub fn SBWatchpointSetCondition(
4951 instance: SBWatchpointRef,
4952 condition: *const ::std::os::raw::c_char,
4953 );
4954 pub fn SBWatchpointGetDescription(
4955 instance: SBWatchpointRef,
4956 description: SBStreamRef,
4957 level: DescriptionLevel,
4958 ) -> bool;
4959 pub fn SBWatchpointClear(instance: SBWatchpointRef);
4960 pub fn SBWatchpointEventIsWatchpointEvent(event: SBEventRef) -> bool;
4961 pub fn SBWatchpointGetWatchpointEventTypeFromEvent(event: SBEventRef) -> WatchpointEventType;
4962 pub fn SBWatchpointGetWatchpointFromEvent(event: SBEventRef) -> SBWatchpointRef;
4963}