1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
|
//===-- SBLaunchInfo.h ------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_API_SBLAUNCHINFO_H
#define LLDB_API_SBLAUNCHINFO_H
#include "lldb/API/SBDefines.h"
namespace lldb_private {
class SBLaunchInfoImpl;
}
namespace lldb {
class SBPlatform;
class SBTarget;
class LLDB_API SBLaunchInfo {
public:
SBLaunchInfo(const char **argv);
~SBLaunchInfo();
SBLaunchInfo(const SBLaunchInfo &rhs);
SBLaunchInfo &operator=(const SBLaunchInfo &rhs);
lldb::pid_t GetProcessID();
uint32_t GetUserID();
uint32_t GetGroupID();
bool UserIDIsValid();
bool GroupIDIsValid();
void SetUserID(uint32_t uid);
void SetGroupID(uint32_t gid);
SBFileSpec GetExecutableFile();
/// Set the executable file that will be used to launch the process and
/// optionally set it as the first argument in the argument vector.
///
/// This only needs to be specified if clients wish to carefully control
/// the exact path will be used to launch a binary. If you create a
/// target with a symlink, that symlink will get resolved in the target
/// and the resolved path will get used to launch the process. Calling
/// this function can help you still launch your process using the
/// path of your choice.
///
/// If this function is not called prior to launching with
/// SBTarget::Launch(...), the target will use the resolved executable
/// path that was used to create the target.
///
/// \param[in] exe_file
/// The override path to use when launching the executable.
///
/// \param[in] add_as_first_arg
/// If true, then the path will be inserted into the argument vector
/// prior to launching. Otherwise the argument vector will be left
/// alone.
void SetExecutableFile(SBFileSpec exe_file, bool add_as_first_arg);
/// Get the listener that will be used to receive process events.
///
/// If no listener has been set via a call to
/// SBLaunchInfo::SetListener(), then an invalid SBListener will be
/// returned (SBListener::IsValid() will return false). If a listener
/// has been set, then the valid listener object will be returned.
SBListener GetListener();
/// Set the listener that will be used to receive process events.
///
/// By default the SBDebugger, which has a listener, that the SBTarget
/// belongs to will listen for the process events. Calling this function
/// allows a different listener to be used to listen for process events.
void SetListener(SBListener &listener);
uint32_t GetNumArguments();
const char *GetArgumentAtIndex(uint32_t idx);
void SetArguments(const char **argv, bool append);
uint32_t GetNumEnvironmentEntries();
const char *GetEnvironmentEntryAtIndex(uint32_t idx);
/// Update this object with the given environment variables.
///
/// If append is false, the provided environment will replace the existing
/// environment. Otherwise, existing values will be updated of left untouched
/// accordingly.
///
/// \param [in] envp
/// The new environment variables as a list of strings with the following
/// format
/// name=value
///
/// \param [in] append
/// Flag that controls whether to replace the existing environment.
void SetEnvironmentEntries(const char **envp, bool append);
/// Update this object with the given environment variables.
///
/// If append is false, the provided environment will replace the existing
/// environment. Otherwise, existing values will be updated of left untouched
/// accordingly.
///
/// \param [in] env
/// The new environment variables.
///
/// \param [in] append
/// Flag that controls whether to replace the existing environment.
void SetEnvironment(const SBEnvironment &env, bool append);
/// Return the environment variables of this object.
///
/// \return
/// An lldb::SBEnvironment object which is a copy of the SBLaunchInfo's
/// environment.
SBEnvironment GetEnvironment();
void Clear();
const char *GetWorkingDirectory() const;
void SetWorkingDirectory(const char *working_dir);
uint32_t GetLaunchFlags();
void SetLaunchFlags(uint32_t flags);
const char *GetProcessPluginName();
void SetProcessPluginName(const char *plugin_name);
const char *GetShell();
void SetShell(const char *path);
bool GetShellExpandArguments();
void SetShellExpandArguments(bool expand);
uint32_t GetResumeCount();
void SetResumeCount(uint32_t c);
bool AddCloseFileAction(int fd);
bool AddDuplicateFileAction(int fd, int dup_fd);
bool AddOpenFileAction(int fd, const char *path, bool read, bool write);
bool AddSuppressFileAction(int fd, bool read, bool write);
void SetLaunchEventData(const char *data);
const char *GetLaunchEventData() const;
bool GetDetachOnError() const;
void SetDetachOnError(bool enable);
protected:
friend class SBPlatform;
friend class SBTarget;
const lldb_private::ProcessLaunchInfo &ref() const;
void set_ref(const lldb_private::ProcessLaunchInfo &info);
std::shared_ptr<lldb_private::SBLaunchInfoImpl> m_opaque_sp;
};
} // namespace lldb
#endif // LLDB_API_SBLAUNCHINFO_H
|
