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
139
140
141
142
143
144
145
146
147
148
|
//===-- cpp11-migrate/Cpp11Migrate.cpp - Main file C++11 migration tool ---===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// \brief This file implements the C++11 feature migration tool main function
/// and transformation framework.
///
/// Usage:
/// cpp11-migrate [-p <build-path>] <file1> <file2> ... [-- [compiler-options]]
///
/// Where <build-path> is a CMake build directory containing a file named
/// compile_commands.json which provides compiler options for building each
/// sourc file. If <build-path> is not provided the compile_commands.json file
/// is searched for through all parent directories.
///
/// Alternatively, one can provide compile options to be applied to every source
/// file after the optional '--'.
///
/// <file1>... specify the paths of files in the CMake source tree, with the
/// same requirements as other tools built on LibTooling.
///
//===----------------------------------------------------------------------===//
#include "Transforms.h"
#include "Transform.h"
#include "clang/Frontend/FrontendActions.h"
#include "clang/Tooling/CommonOptionsParser.h"
#include "clang/Tooling/Tooling.h"
#include "llvm/Support/Signals.h"
namespace cl = llvm::cl;
using namespace clang::tooling;
static cl::opt<RiskLevel> MaxRiskLevel(
"risk", cl::desc("Select a maximum risk level:"),
cl::values(clEnumValN(RL_Safe, "safe", "Only safe transformations"),
clEnumValN(RL_Reasonable, "reasonable",
"Enable transformations that might change "
"semantics (default)"),
clEnumValN(RL_Risky, "risky",
"Enable transformations that are likely to "
"change semantics"),
clEnumValEnd),
cl::init(RL_Reasonable));
static cl::opt<bool> FinalSyntaxCheck(
"final-syntax-check",
cl::desc("Check for correct syntax after applying transformations"),
cl::init(false));
static cl::opt<bool>
SummaryMode("summary", cl::desc("Print transform summary"),
cl::init(false));
class EndSyntaxArgumentsAdjuster : public ArgumentsAdjuster {
CommandLineArguments Adjust(const CommandLineArguments &Args) {
CommandLineArguments AdjustedArgs = Args;
AdjustedArgs.push_back("-fsyntax-only");
AdjustedArgs.push_back("-std=c++11");
return AdjustedArgs;
}
};
int main(int argc, const char **argv) {
llvm::sys::PrintStackTraceOnErrorSignal();
Transforms TransformManager;
TransformManager.createTransformOpts();
// This causes options to be parsed.
CommonOptionsParser OptionsParser(argc, argv);
TransformManager.createSelectedTransforms();
if (TransformManager.begin() == TransformManager.end()) {
llvm::errs() << "No selected transforms\n";
return 1;
}
FileContentsByPath FileStates1, FileStates2,
*InputFileStates = &FileStates1, *OutputFileStates = &FileStates2;
// Apply transforms.
for (Transforms::const_iterator I = TransformManager.begin(),
E = TransformManager.end();
I != E; ++I) {
if ((*I)->apply(*InputFileStates, MaxRiskLevel,
OptionsParser.getCompilations(),
OptionsParser.getSourcePathList(), *OutputFileStates) !=
0) {
// FIXME: Improve ClangTool to not abort if just one file fails.
return 1;
}
if (SummaryMode) {
llvm::outs() << "Transform: " << (*I)->getName()
<< " - Accepted: "
<< (*I)->getAcceptedChanges();
if ((*I)->getChangesNotMade()) {
llvm::outs() << " - Rejected: "
<< (*I)->getRejectedChanges()
<< " - Deferred: "
<< (*I)->getDeferredChanges();
}
llvm::outs() << "\n";
}
std::swap(InputFileStates, OutputFileStates);
OutputFileStates->clear();
}
// Final state of files is pointed at by InputFileStates.
if (FinalSyntaxCheck) {
ClangTool EndSyntaxTool(OptionsParser.getCompilations(),
OptionsParser.getSourcePathList());
// Add c++11 support to clang.
EndSyntaxTool.setArgumentsAdjuster(new EndSyntaxArgumentsAdjuster);
for (FileContentsByPath::const_iterator I = InputFileStates->begin(),
E = InputFileStates->end();
I != E; ++I) {
EndSyntaxTool.mapVirtualFile(I->first, I->second);
}
if (EndSyntaxTool.run(newFrontendActionFactory<clang::SyntaxOnlyAction>())
!= 0) {
return 1;
}
}
// Write results to file.
for (FileContentsByPath::const_iterator I = InputFileStates->begin(),
E = InputFileStates->end();
I != E; ++I) {
std::string ErrorInfo;
llvm::raw_fd_ostream FileStream(I->first.c_str(), ErrorInfo,
llvm::raw_fd_ostream::F_Binary);
FileStream << I->second;
}
return 0;
}
|
