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