#include <stdexcept>
using namespace llvm;
+using namespace llvmc;
extern cl::opt<bool> VerboseMode;
namespace {
int ExecuteProgram(const std::string& name,
- const std::vector<std::string>& args) {
+ const StringVector& args) {
sys::Path prog = sys::Program::FindProgramByName(name);
if (prog.isEmpty())
if (!prog.canExecute())
throw std::runtime_error("Program '" + name + "' is not executable.");
- // Invoke the program
- std::vector<const char*> argv((args.size()+2));
- argv[0] = name.c_str();
- for (unsigned i = 1; i <= args.size(); ++i)
- argv[i] = args[i-1].c_str();
- argv[args.size()+1] = 0; // null terminate list.
+ const sys::Path* redirects[3] = {0,0,0};
+ sys::Path stdout_redirect;
- return sys::Program::ExecuteAndWait(prog, &argv[0]);
+ std::vector<const char*> argv;
+ argv.reserve((args.size()+2));
+ argv.push_back(name.c_str());
+
+ for (StringVector::const_iterator B = args.begin(), E = args.end();
+ B!=E; ++B) {
+ if (*B == ">") {
+ ++B;
+ stdout_redirect.set(*B);
+ redirects[1] = &stdout_redirect;
+ }
+ else {
+ argv.push_back((*B).c_str());
+ }
+ }
+ argv.push_back(0); // null terminate list.
+
+ return sys::Program::ExecuteAndWait(prog, &argv[0], 0, &redirects[0]);
}
void print_string (const std::string& str) {
}
}
-int llvmcc::Action::Execute() const {
+int llvmc::Action::Execute() const {
if (VerboseMode) {
std::cerr << Command_ << " ";
std::for_each(Args_.begin(), Args_.end(), print_string);
#include <string>
#include <vector>
-namespace llvmcc {
+namespace llvmc {
+
+ typedef std::vector<std::string> StringVector;
class Action {
std::string Command_;
std::vector<std::string> Args_;
public:
- Action (std::string const& C,
- std::vector<std::string> const& A)
+ Action (const std::string& C,
+ const StringVector& A)
: Command_(C), Args_(A)
{}
#include <stdexcept>
using namespace llvm;
-using namespace llvmcc;
+using namespace llvmc;
// The auto-generated file
#include "AutoGenerated.inc"
#include <string>
-namespace llvmcc {
+namespace llvmc {
typedef llvm::StringMap<std::string> LanguageMap;
class CompilationGraph;
#include <stdexcept>
using namespace llvm;
-using namespace llvmcc;
+using namespace llvmc;
extern cl::list<std::string> InputFilenames;
extern cl::opt<std::string> OutputFilename;
return &getNode(ChooseEdge(TV)->ToolName());
}
+// TOFIX: merge some parts with PassThroughGraph.
+// Build the targets. Command-line options are passed through
+// temporary variables.
int CompilationGraph::Build (const sys::Path& TempDir) {
// For each input file:
// For all join nodes in topological order:
for (std::vector<const Node*>::iterator B = JTV.begin(), E = JTV.end();
B != E; ++B) {
- // TOFIX: more testing, merge some parts with PassThroughGraph.
+
sys::Path Out;
const Node* CurNode = *B;
JoinTool* JT = &dynamic_cast<JoinTool&>(*CurNode->ToolPtr.getPtr());
bool IsLast = false;
+ // Has files pending?
if (JT->JoinListEmpty())
continue;
namespace llvm {
template <>
- struct DOTGraphTraits<llvmcc::CompilationGraph*>
+ struct DOTGraphTraits<llvmc::CompilationGraph*>
: public DefaultDOTGraphTraits
{
#include <string>
-namespace llvmcc {
+namespace llvmc {
// An edge in the graph.
class Edge : public llvm::RefCountedBaseVPTR<Edge> {
namespace llvm {
template <>
- struct GraphTraits<llvmcc::CompilationGraph*> {
- typedef llvmcc::CompilationGraph GraphType;
- typedef llvmcc::Node NodeType;
- typedef llvmcc::NodeChildIterator ChildIteratorType;
+ struct GraphTraits<llvmc::CompilationGraph*> {
+ typedef llvmc::CompilationGraph GraphType;
+ typedef llvmc::Node NodeType;
+ typedef llvmc::NodeChildIterator ChildIteratorType;
static NodeType* getEntryNode(GraphType* G) {
return &G->getNode("root");
return ChildIteratorType(N, N->OutEdges.end());
}
- typedef llvmcc::NodesIterator nodes_iterator;
+ typedef llvmc::NodesIterator nodes_iterator;
static nodes_iterator nodes_begin(GraphType *G) {
return GraphBegin(G);
}
#include "llvm/ADT/StringExtras.h"
-void llvmcc::Tool::UnpackValues (const std::string& from,
+void llvmc::Tool::UnpackValues (const std::string& from,
std::vector<std::string>& to) {
llvm::SplitString(from, to, ",");
}
#include <string>
#include <vector>
-namespace llvmcc {
+namespace llvmc {
typedef std::vector<llvm::sys::Path> PathVector;
-//===--- llvmcc.cpp - The LLVM Compiler Driver ------------------*- C++ -*-===//
+//===--- llvmc.cpp - The LLVM Compiler Driver ------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
namespace cl = llvm::cl;
namespace sys = llvm::sys;
-using namespace llvmcc;
+using namespace llvmc;
// Built-in command-line options.
// External linkage here is intentional.
-//===- LLVMCConfigurationEmitter.cpp - Generate LLVMCC config -------------===//
+//===- LLVMCConfigurationEmitter.cpp - Generate LLVMC config --------------===//
//
// The LLVM Compiler Infrastructure
//
//
//===----------------------------------------------------------------------===//
//
-// This tablegen backend is responsible for emitting LLVMCC configuration code.
+// This tablegen backend is responsible for emitting LLVMC configuration code.
//
//===----------------------------------------------------------------------===//
throw std::string("Error in the language map definition!");
// Generate code
- O << "void llvmcc::PopulateLanguageMap(LanguageMap& language_map) {\n";
+ O << "void llvmc::PopulateLanguageMap(LanguageMap& language_map) {\n";
for (unsigned i = 0; i < LangsToSuffixesList->size(); ++i) {
Record* LangToSuffixes = LangsToSuffixesList->getElementAsRecord(i);
ListInit* edges = CompilationGraph->getValueAsListInit("edges");
// Generate code
- O << "void llvmcc::PopulateCompilationGraph(CompilationGraph& G) {\n"
+ O << "void llvmc::PopulateCompilationGraph(CompilationGraph& G) {\n"
<< Indent1 << "PopulateLanguageMap(G.ExtsToLangs);\n\n";
// Insert vertices
// Back-end entry point
void LLVMCCConfigurationEmitter::run (std::ostream &O) {
// Emit file header
- EmitSourceFileHeader("LLVMCC Configuration Library", O);
+ EmitSourceFileHeader("LLVMC Configuration Library", O);
// Get a list of all defined Tools
RecordVector Tools = Records.getAllDerivedDefinitions("Tool");