1 //===--- Job.h - Commands to Execute ----------------------------*- 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 #ifndef CLANG_DRIVER_JOB_H_ 11 #define CLANG_DRIVER_JOB_H_ 12 13 #include "clang/Basic/LLVM.h" 14 #include "llvm/ADT/SmallVector.h" 15 #include "llvm/Option/Option.h" 16 #include <memory> 17 18 namespace llvm { 19 class raw_ostream; 20 } 21 22 namespace clang { 23 namespace driver { 24 class Action; 25 class Command; 26 class Tool; 27 28 // Re-export this as clang::driver::ArgStringList. 29 using llvm::opt::ArgStringList; 30 31 class Job { 32 public: 33 enum JobClass { 34 CommandClass, 35 FallbackCommandClass, 36 JobListClass 37 }; 38 39 private: 40 JobClass Kind; 41 42 protected: Job(JobClass _Kind)43 Job(JobClass _Kind) : Kind(_Kind) {} 44 public: 45 virtual ~Job(); 46 getKind()47 JobClass getKind() const { return Kind; } 48 49 /// Print - Print this Job in -### format. 50 /// 51 /// \param OS - The stream to print on. 52 /// \param Terminator - A string to print at the end of the line. 53 /// \param Quote - Should separate arguments be quoted. 54 /// \param CrashReport - Whether to print for inclusion in a crash report. 55 virtual void Print(llvm::raw_ostream &OS, const char *Terminator, 56 bool Quote, bool CrashReport = false) const = 0; 57 }; 58 59 /// Command - An executable path/name and argument vector to 60 /// execute. 61 class Command : public Job { 62 /// Source - The action which caused the creation of this job. 63 const Action &Source; 64 65 /// Tool - The tool which caused the creation of this job. 66 const Tool &Creator; 67 68 /// The executable to run. 69 const char *Executable; 70 71 /// The list of program arguments (not including the implicit first 72 /// argument, which will be the executable). 73 llvm::opt::ArgStringList Arguments; 74 75 public: 76 Command(const Action &_Source, const Tool &_Creator, const char *_Executable, 77 const llvm::opt::ArgStringList &_Arguments); 78 79 void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, 80 bool CrashReport = false) const override; 81 82 virtual int Execute(const StringRef **Redirects, std::string *ErrMsg, 83 bool *ExecutionFailed) const; 84 85 /// getSource - Return the Action which caused the creation of this job. getSource()86 const Action &getSource() const { return Source; } 87 88 /// getCreator - Return the Tool which caused the creation of this job. getCreator()89 const Tool &getCreator() const { return Creator; } 90 getExecutable()91 const char *getExecutable() const { return Executable; } 92 getArguments()93 const llvm::opt::ArgStringList &getArguments() const { return Arguments; } 94 classof(const Job * J)95 static bool classof(const Job *J) { 96 return J->getKind() == CommandClass || 97 J->getKind() == FallbackCommandClass; 98 } 99 }; 100 101 /// Like Command, but with a fallback which is executed in case 102 /// the primary command crashes. 103 class FallbackCommand : public Command { 104 public: 105 FallbackCommand(const Action &Source_, const Tool &Creator_, 106 const char *Executable_, const ArgStringList &Arguments_, 107 Command *Fallback_); 108 109 void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote, 110 bool CrashReport = false) const override; 111 112 int Execute(const StringRef **Redirects, std::string *ErrMsg, 113 bool *ExecutionFailed) const override; 114 classof(const Job * J)115 static bool classof(const Job *J) { 116 return J->getKind() == FallbackCommandClass; 117 } 118 119 private: 120 std::unique_ptr<Command> Fallback; 121 }; 122 123 /// JobList - A sequence of jobs to perform. 124 class JobList : public Job { 125 public: 126 typedef SmallVector<Job*, 4> list_type; 127 typedef list_type::size_type size_type; 128 typedef list_type::iterator iterator; 129 typedef list_type::const_iterator const_iterator; 130 131 private: 132 list_type Jobs; 133 134 public: 135 JobList(); 136 virtual ~JobList(); 137 138 void Print(llvm::raw_ostream &OS, const char *Terminator, 139 bool Quote, bool CrashReport = false) const override; 140 141 /// Add a job to the list (taking ownership). addJob(Job * J)142 void addJob(Job *J) { Jobs.push_back(J); } 143 144 /// Clear the job list. 145 void clear(); 146 getJobs()147 const list_type &getJobs() const { return Jobs; } 148 size()149 size_type size() const { return Jobs.size(); } begin()150 iterator begin() { return Jobs.begin(); } begin()151 const_iterator begin() const { return Jobs.begin(); } end()152 iterator end() { return Jobs.end(); } end()153 const_iterator end() const { return Jobs.end(); } 154 classof(const Job * J)155 static bool classof(const Job *J) { 156 return J->getKind() == JobListClass; 157 } 158 }; 159 160 } // end namespace driver 161 } // end namespace clang 162 163 #endif 164