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 SBLaunchInfo::SBLaunchInfo(const char **argv)
  20     : m_opaque_sp(new ProcessLaunchInfo()) {
  21   m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
  22   if (argv && argv[0])
  23     m_opaque_sp->GetArguments().SetArguments(argv);
  24 }
  25
  26 SBLaunchInfo::~SBLaunchInfo() {}
  27
  28 lldb_private::ProcessLaunchInfo &SBLaunchInfo::ref() { return *m_opaque_sp; }
  29
  30 const lldb_private::ProcessLaunchInfo &SBLaunchInfo::ref() const {
  31   return *m_opaque_sp;
  32 }
  33
  34 lldb::pid_t SBLaunchInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); }
  35
  36 uint32_t SBLaunchInfo::GetUserID() { return m_opaque_sp->GetUserID(); }
  37
  38 uint32_t SBLaunchInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
  39
  40 bool SBLaunchInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
  41
  42 bool SBLaunchInfo::GroupIDIsValid() { return m_opaque_sp->GroupIDIsValid(); }
  43
  44 void SBLaunchInfo::SetUserID(uint32_t uid) { m_opaque_sp->SetUserID(uid); }
  45
  46 void SBLaunchInfo::SetGroupID(uint32_t gid) { m_opaque_sp->SetGroupID(gid); }
  47
  48 SBFileSpec SBLaunchInfo::GetExecutableFile() {
  49   return SBFileSpec(m_opaque_sp->GetExecutableFile());
  50 }
  51
  52 void SBLaunchInfo::SetExecutableFile(SBFileSpec exe_file,
  53                                      bool add_as_first_arg) {
  54   m_opaque_sp->SetExecutableFile(exe_file.ref(), add_as_first_arg);
  55 }
  56
  57 SBListener SBLaunchInfo::GetListener() {
  58   return SBListener(m_opaque_sp->GetListener());
  59 }
  60
  61 void SBLaunchInfo::SetListener(SBListener &listener) {
  62   m_opaque_sp->SetListener(listener.GetSP());
  63 }
  64
  65 uint32_t SBLaunchInfo::GetNumArguments() {
  66   return m_opaque_sp->GetArguments().GetArgumentCount();
  67 }
  68
  69 const char *SBLaunchInfo::GetArgumentAtIndex(uint32_t idx) {
  70   return m_opaque_sp->GetArguments().GetArgumentAtIndex(idx);
  71 }
  72
  73 void SBLaunchInfo::SetArguments(const char **argv, bool append) {
  74   if (append) {
  75     if (argv)
  76       m_opaque_sp->GetArguments().AppendArguments(argv);
  77   } else {
  78     if (argv)
  79       m_opaque_sp->GetArguments().SetArguments(argv);
  80     else
  81       m_opaque_sp->GetArguments().Clear();
  82   }
  83 }
  84
  85 uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
  86   return m_opaque_sp->GetEnvironmentEntries().GetArgumentCount();
  87 }
  88
  89 const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
  90   return m_opaque_sp->GetEnvironmentEntries().GetArgumentAtIndex(idx);
  91 }
  92
  93 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
  94   if (append) {
  95     if (envp)
  96       m_opaque_sp->GetEnvironmentEntries().AppendArguments(envp);
  97   } else {
  98     if (envp)
  99       m_opaque_sp->GetEnvironmentEntries().SetArguments(envp);
 100     else
 101       m_opaque_sp->GetEnvironmentEntries().Clear();
 102   }
 103 }
 104
 105 void SBLaunchInfo::Clear() { m_opaque_sp->Clear(); }
 106
 107 const char *SBLaunchInfo::GetWorkingDirectory() const {
 108   return m_opaque_sp->GetWorkingDirectory().GetCString();
 109 }
 110
 111 void SBLaunchInfo::SetWorkingDirectory(const char *working_dir) {
 112   m_opaque_sp->SetWorkingDirectory(FileSpec{working_dir, false});
 113 }
 114
 115 uint32_t SBLaunchInfo::GetLaunchFlags() {
 116   return m_opaque_sp->GetFlags().Get();
 117 }
 118
 119 void SBLaunchInfo::SetLaunchFlags(uint32_t flags) {
 120   m_opaque_sp->GetFlags().Reset(flags);
 121 }
 122
 123 const char *SBLaunchInfo::GetProcessPluginName() {
 124   return m_opaque_sp->GetProcessPluginName();
 125 }
 126
 127 void SBLaunchInfo::SetProcessPluginName(const char *plugin_name) {
 128   return m_opaque_sp->SetProcessPluginName(plugin_name);
 129 }
 130
 131 const char *SBLaunchInfo::GetShell() {
 132   // Constify this string so that it is saved in the string pool.  Otherwise
 133   // it would be freed when this function goes out of scope.
 134   ConstString shell(m_opaque_sp->GetShell().GetPath().c_str());
 135   return shell.AsCString();
 136 }
 137
 138 void SBLaunchInfo::SetShell(const char *path) {
 139   m_opaque_sp->SetShell(FileSpec(path, false));
 140 }
 141
 142 bool SBLaunchInfo::GetShellExpandArguments() {
 143   return m_opaque_sp->GetShellExpandArguments();
 144 }
 145
 146 void SBLaunchInfo::SetShellExpandArguments(bool expand) {
 147   m_opaque_sp->SetShellExpandArguments(expand);
 148 }
 149
 150 uint32_t SBLaunchInfo::GetResumeCount() {
 151   return m_opaque_sp->GetResumeCount();
 152 }
 153
 154 void SBLaunchInfo::SetResumeCount(uint32_t c) {
 155   m_opaque_sp->SetResumeCount(c);
 156 }
 157
 158 bool SBLaunchInfo::AddCloseFileAction(int fd) {
 159   return m_opaque_sp->AppendCloseFileAction(fd);
 160 }
 161
 162 bool SBLaunchInfo::AddDuplicateFileAction(int fd, int dup_fd) {
 163   return m_opaque_sp->AppendDuplicateFileAction(fd, dup_fd);
 164 }
 165
 166 bool SBLaunchInfo::AddOpenFileAction(int fd, const char *path, bool read,
 167                                      bool write) {
 168   return m_opaque_sp->AppendOpenFileAction(fd, FileSpec{path, false}, read,
 169                                            write);
 170 }
 171
 172 bool SBLaunchInfo::AddSuppressFileAction(int fd, bool read, bool write) {
 173   return m_opaque_sp->AppendSuppressFileAction(fd, read, write);
 174 }
 175
 176 void SBLaunchInfo::SetLaunchEventData(const char *data) {
 177   m_opaque_sp->SetLaunchEventData(data);
 178 }
 179
 180 const char *SBLaunchInfo::GetLaunchEventData() const {
 181   return m_opaque_sp->GetLaunchEventData();
 182 }
 183
 184 void SBLaunchInfo::SetDetachOnError(bool enable) {
 185   m_opaque_sp->SetDetachOnError(enable);
 186 }
 187
 188 bool SBLaunchInfo::GetDetachOnError() const {
 189   return m_opaque_sp->GetDetachOnError();
 190 }