blob: f60f5146414c37e4cacf81fe360d3d66092ed10c (
plain)
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
|
//===--- Job.h - Commands to Execute ----------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef CLANG_DRIVER_JOB_H_
#define CLANG_DRIVER_JOB_H_
#include "clang/Driver/Util.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Casting.h"
using llvm::isa;
using llvm::cast;
using llvm::cast_or_null;
using llvm::dyn_cast;
using llvm::dyn_cast_or_null;
namespace clang {
namespace driver {
class Command;
class Job {
public:
enum JobClass {
CommandClass,
PipedJobClass,
JobListClass
};
private:
JobClass Kind;
protected:
Job(JobClass _Kind) : Kind(_Kind) {}
public:
virtual ~Job();
JobClass getKind() const { return Kind; }
/// addCommand - Append a command to the current job, which must be
/// either a piped job or a job list.
void addCommand(Command *C);
static bool classof(const Job *) { return true; }
};
/// Command - An executable path/name and argument vector to
/// execute.
class Command : public Job {
/// The executable to run.
const char *Executable;
/// The list of program arguments (not including the implicit first
/// argument, which will be the executable).
ArgStringList Arguments;
public:
Command(const char *_Executable, const ArgStringList &_Arguments);
const char *getExecutable() const { return Executable; }
const ArgStringList &getArguments() const { return Arguments; }
static bool classof(const Job *J) {
return J->getKind() == CommandClass;
}
static bool classof(const Command *) { return true; }
};
/// PipedJob - A list of Commands which should be executed together
/// with their standard inputs and outputs connected.
class PipedJob : public Job {
public:
typedef llvm::SmallVector<Command*, 4> list_type;
typedef list_type::size_type size_type;
typedef list_type::iterator iterator;
typedef list_type::const_iterator const_iterator;
private:
list_type Commands;
public:
PipedJob();
void addCommand(Command *C) { Commands.push_back(C); }
const list_type &getCommands() const { return Commands; }
size_type size() const { return Commands.size(); }
iterator begin() { return Commands.begin(); }
const_iterator begin() const { return Commands.begin(); }
iterator end() { return Commands.end(); }
const_iterator end() const { return Commands.end(); }
static bool classof(const Job *J) {
return J->getKind() == PipedJobClass;
}
static bool classof(const PipedJob *) { return true; }
};
/// JobList - A sequence of jobs to perform.
class JobList : public Job {
public:
typedef llvm::SmallVector<Job*, 4> list_type;
typedef list_type::size_type size_type;
typedef list_type::iterator iterator;
typedef list_type::const_iterator const_iterator;
private:
list_type Jobs;
public:
JobList();
void addJob(Job *J) { Jobs.push_back(J); }
const list_type &getJobs() const { return Jobs; }
size_type size() const { return Jobs.size(); }
iterator begin() { return Jobs.begin(); }
const_iterator begin() const { return Jobs.begin(); }
iterator end() { return Jobs.end(); }
const_iterator end() const { return Jobs.end(); }
static bool classof(const Job *J) {
return J->getKind() == JobListClass;
}
static bool classof(const JobList *) { return true; }
};
} // end namespace driver
} // end namespace clang
#endif
|
