contrib/llvm/tools/lldb/source/API/SBLaunchInfo.cpp

   1 //===-- SBLaunchInfo.cpp ----------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/API/SBLaunchInfo.h"
  11
  12 #include "lldb/API/SBFileSpec.h"
  13 #include "lldb/API/SBListener.h"
  14 #include "lldb/Target/ProcessLaunchInfo.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo {
  20 public:
  21   SBLaunchInfoImpl()
  22       : ProcessLaunchInfo(), m_envp(GetEnvironment().getEnvp()) {}
  23
  24   const char *const *GetEnvp() const { return m_envp; }
  25   void RegenerateEnvp() { m_envp = GetEnvironment().getEnvp(); }
  26
  27   SBLaunchInfoImpl &operator=(const ProcessLaunchInfo &rhs) {
  28     ProcessLaunchInfo::operator=(rhs);
  29     RegenerateEnvp();
  30     return *this;
  31   }
  32
  33 private:
  34   Environment::Envp m_envp;
  35 };
  36
  37 SBLaunchInfo::SBLaunchInfo(const char **argv)
  38     : m_opaque_sp(new SBLaunchInfoImpl()) {
  39   m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
  40   if (argv && argv[0])
  41     m_opaque_sp->GetArguments().SetArguments(argv);
  42 }
  43
  44 SBLaunchInfo::~SBLaunchInfo() {}
  45
  46 const lldb_private::ProcessLaunchInfo &SBLaunchInfo::ref() const {
  47   return *m_opaque_sp;
  48 }
  49
  50 void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) {
  51   *m_opaque_sp = info;
  52 }
  53
  54 lldb::pid_t SBLaunchInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); }
  55
  56 uint32_t SBLaunchInfo::GetUserID() { return m_opaque_sp->GetUserID(); }
  57
  58 uint32_t SBLaunchInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
  59
  60 bool SBLaunchInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
  61
  62 bool SBLaunchInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
  63
  64 void SBLaunchInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
  65
  66 void SBLaunchInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); }
  67
  68 SBFileSpec SBLaunchInfo::GetExecutableFile() {
  69   return SBFileSpec(m_opaque_sp->GetExecutableFile());
  70 }
  71
  72 void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file,
  73                                      bool add_as_first_arg) {
  74   m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
  75 }
  76
  77 SBListener SBLaunchInfo::GetListener() {
  78   return SBListener(m_opaque_sp->GetListener());
  79 }
  80
  81 void SBLaunchInfo::SetListener(SBListener &listener) {
  82   m_opaque_sp->SetListener(listener.GetSP());
  83 }
  84
  85 uint32_t SBLaunchInfo::GetNumArguments() {
  86   return m_opaque_sp->GetArguments().GetArgumentCount();
  87 }
  88
  89 const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
  90   return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
  91 }
  92
  93 void SBLaunchInfo::SetArguments(const char **argv, bool append) {
  94   if (append) {
  95     if (argv)
  96       m_opaque_sp->GetArguments().AppendArguments(argv);
  97   } else {
  98     if (argv)
  99       m_opaque_sp->GetArguments().SetArguments(argv);
 100     else
 101       m_opaque_sp->GetArguments().Clear();
 102   }
 103 }
 104
 105 uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
 106   return m_opaque_sp->GetEnvironment().size();
 107 }
 108
 109 const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
 110   if (idx > GetNumEnvironmentEntries())
 111     return nullptr;
 112   return m_opaque_sp->GetEnvp()[idx];
 113 }
 114
 115 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
 116   Environment env(envp);
 117   if (append)
 118     m_opaque_sp->GetEnvironment().insert(env.begin(), env.end());
 119   else
 120     m_opaque_sp->GetEnvironment() = env;
 121   m_opaque_sp->RegenerateEnvp();
 122 }
 123
 124 void SBLaunchInfo::Clear() { m_opaque_sp->Clear(); }
 125
 126 const char *SBLaunchInfo::GetWorkingDirectory() const {
 127   return m_opaque_sp->GetWorkingDirectory().GetCString();
 128 }
 129
 130 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
 131   m_opaque_sp->SetWorkingDirectory(FileSpec{working_dir, false});
 132 }
 133
 134 uint32_t SBLaunchInfo::GetLaunchFlags() {
 135   return m_opaque_sp->GetFlags().Get();
 136 }
 137
 138 void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
 139   m_opaque_sp->GetFlags().Reset(flags);
 140 }
 141
 142 const char *SBLaunchInfo::GetProcessPluginName() {
 143   return m_opaque_sp->GetProcessPluginName();
 144 }
 145
 146 void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
 147   return m_opaque_sp->SetProcessPluginName(plugin_name);
 148 }
 149
 150 const char *SBLaunchInfo::GetShell() {
 151   // Constify this string so that it is saved in the string pool.  Otherwise it
 152   // would be freed when this function goes out of scope.
 153   ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
 154   return shell.AsCString();
 155 }
 156
 157 void SBLaunchInfo::SetShell(const char *path) {
 158   m_opaque_sp->SetShell(FileSpec(path, false));
 159 }
 160
 161 bool SBLaunchInfo::GetShellExpandArguments() {
 162   return m_opaque_sp->GetShellExpandArguments();
 163 }
 164
 165 void SBLaunchInfo::SetShellExpandArguments(bool expand) {
 166   m_opaque_sp->SetShellExpandArguments(expand);
 167 }
 168
 169 uint32_t SBLaunchInfo::GetResumeCount() {
 170   return m_opaque_sp->GetResumeCount();
 171 }
 172
 173 void SBLaunchInfo::SetResumeCount(uint32_t c) {
 174   m_opaque_sp->SetResumeCount(c);
 175 }
 176
 177 bool SBLaunchInfo::AddCloseFileAction(int fd) {
 178   return m_opaque_sp->AppendCloseFileAction(fd);
 179 }
 180
 181 bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
 182   return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
 183 }
 184
 185 bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read,
 186                                      bool write) {
 187   return m_opaque_sp->AppendOpenFileAction(fd, FileSpec{path, false}, read,
 188                                            write);
 189 }
 190
 191 bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {
 192   return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
 193 }
 194
 195 void SBLaunchInfo::SetLaunchEventData(const char *data) {
 196   m_opaque_sp->SetLaunchEventData(data);
 197 }
 198
 199 const char *SBLaunchInfo::GetLaunchEventData() const {
 200   return m_opaque_sp->GetLaunchEventData();
 201 }
 202
 203 void SBLaunchInfo::SetDetachOnError(bool enable) {
 204   m_opaque_sp->SetDetachOnError(enable);
 205 }
 206
 207 bool SBLaunchInfo::GetDetachOnError() const {
 208   return m_opaque_sp->GetDetachOnError();
 209 }