blob: 979bb67ed8d2ba2e58db101a3e8b4a94102da9da [file] [log] [blame]
Zonr Changc383a502010-10-12 01:52:08 +08001/*
Stephen Hines0a813a32012-08-03 16:52:40 -07002 * Copyright 2010-2012, The Android Open Source Project
Zonr Changc383a502010-10-12 01:52:08 +08003 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
Zonr Chang3a9ca1f2010-10-06 17:52:56 +080017#include "slang_rs.h"
18
Shih-wei Liaob81c6a42010-10-10 14:15:00 -070019#include <cstring>
Stephen Hinese639eb52010-11-08 19:27:20 -080020#include <list>
Stephen Hines2e35b132011-07-22 02:50:19 -070021#include <sstream>
Stephen Hinese639eb52010-11-08 19:27:20 -080022#include <string>
23#include <utility>
24#include <vector>
Stephen Hinesfcda2352010-10-19 16:49:32 -070025
Loganbe274822011-02-16 22:02:54 +080026#include "clang/Basic/SourceLocation.h"
27
Zonr Changcf6af6a2010-10-12 12:38:51 +080028#include "clang/Frontend/FrontendDiagnostic.h"
29
Zonr Chang3a9ca1f2010-10-06 17:52:56 +080030#include "clang/Sema/SemaDiagnostic.h"
31
Loganbe274822011-02-16 22:02:54 +080032#include "llvm/Support/Path.h"
Stephen Hinese639eb52010-11-08 19:27:20 -080033
Raphael8d5a2f62011-02-08 00:15:05 -080034#include "os_sep.h"
Stephen Hines7f5704e2014-06-10 18:06:50 -070035#include "rs_cc_options.h"
Zonr Chang3a9ca1f2010-10-06 17:52:56 +080036#include "slang_rs_backend.h"
37#include "slang_rs_context.h"
Zonr Chang641558f2010-10-12 21:07:06 +080038#include "slang_rs_export_type.h"
Zonr Chang3a9ca1f2010-10-06 17:52:56 +080039
Jean-Luc Brouillet12fc2832014-06-04 21:32:31 +000040#include "slang_rs_reflection.h"
Jason Sams1b6a0882012-03-12 15:07:58 -070041#include "slang_rs_reflection_cpp.h"
42
Stephen Hinese639eb52010-11-08 19:27:20 -080043namespace slang {
Zonr Chang3a9ca1f2010-10-06 17:52:56 +080044
Stephen Hines11274a72012-09-26 19:14:20 -070045#define FS_SUFFIX "fs"
46
Zonr Chang3c250c52010-10-07 12:19:23 +080047#define RS_HEADER_SUFFIX "rsh"
48
Stephen Hines2d35edd2011-08-09 11:33:27 -070049/* RS_HEADER_ENTRY(name) */
Zonr Chang3c250c52010-10-07 12:19:23 +080050#define ENUM_RS_HEADER() \
Stephen Hines2d35edd2011-08-09 11:33:27 -070051 RS_HEADER_ENTRY(rs_allocation) \
52 RS_HEADER_ENTRY(rs_atomic) \
53 RS_HEADER_ENTRY(rs_cl) \
54 RS_HEADER_ENTRY(rs_core) \
Stephen Hinesa7ab54d2014-01-08 09:41:49 -080055 RS_HEADER_ENTRY(rs_core_math) \
Stephen Hines2d35edd2011-08-09 11:33:27 -070056 RS_HEADER_ENTRY(rs_debug) \
Alex Sakhartchouk4eb4b382012-03-21 09:58:39 -070057 RS_HEADER_ENTRY(rs_element) \
Stephen Hines2d35edd2011-08-09 11:33:27 -070058 RS_HEADER_ENTRY(rs_graphics) \
59 RS_HEADER_ENTRY(rs_math) \
Alex Sakhartchouk4eb4b382012-03-21 09:58:39 -070060 RS_HEADER_ENTRY(rs_mesh) \
Stephen Hines2d35edd2011-08-09 11:33:27 -070061 RS_HEADER_ENTRY(rs_matrix) \
62 RS_HEADER_ENTRY(rs_object) \
Alex Sakhartchouk4eb4b382012-03-21 09:58:39 -070063 RS_HEADER_ENTRY(rs_program) \
Stephen Hines2d35edd2011-08-09 11:33:27 -070064 RS_HEADER_ENTRY(rs_quaternion) \
Alex Sakhartchouk4eb4b382012-03-21 09:58:39 -070065 RS_HEADER_ENTRY(rs_sampler) \
Stephen Hines2d35edd2011-08-09 11:33:27 -070066 RS_HEADER_ENTRY(rs_time) \
67 RS_HEADER_ENTRY(rs_types) \
68
Stephen Hines11274a72012-09-26 19:14:20 -070069// Returns true if \p Filename ends in ".fs".
70bool SlangRS::isFilterscript(const char *Filename) {
71 const char *c = strrchr(Filename, '.');
72 if (c && !strncmp(FS_SUFFIX, c + 1, strlen(FS_SUFFIX) + 1)) {
73 return true;
74 } else {
75 return false;
76 }
77}
Zonr Chang3c250c52010-10-07 12:19:23 +080078
Jean-Luc Brouillet129fd822014-05-28 17:46:10 -070079bool SlangRS::generateJavaBitcodeAccessor(const std::string &OutputPathBase,
Jean-Luc Brouillet12fc2832014-06-04 21:32:31 +000080 const std::string &PackageName,
81 const std::string *LicenseNote) {
Zonr Changcf6af6a2010-10-12 12:38:51 +080082 RSSlangReflectUtils::BitCodeAccessorContext BCAccessorContext;
83
84 BCAccessorContext.rsFileName = getInputFileName().c_str();
85 BCAccessorContext.bcFileName = getOutputFileName().c_str();
86 BCAccessorContext.reflectPath = OutputPathBase.c_str();
87 BCAccessorContext.packageName = PackageName.c_str();
Jean-Luc Brouillet129fd822014-05-28 17:46:10 -070088 BCAccessorContext.licenseNote = LicenseNote;
Zonr Changcf6af6a2010-10-12 12:38:51 +080089 BCAccessorContext.bcStorage = BCST_JAVA_CODE; // Must be BCST_JAVA_CODE
90
Jean-Luc Brouillet129fd822014-05-28 17:46:10 -070091 return RSSlangReflectUtils::GenerateJavaBitCodeAccessor(BCAccessorContext);
Zonr Changcf6af6a2010-10-12 12:38:51 +080092}
93
Zonr Change86245a2010-10-12 21:42:13 +080094bool SlangRS::checkODR(const char *CurInputFile) {
Zonr Chang641558f2010-10-12 21:07:06 +080095 for (RSContext::ExportableList::iterator I = mRSContext->exportable_begin(),
96 E = mRSContext->exportable_end();
97 I != E;
98 I++) {
Stephen Hinesa858cb62011-01-17 12:17:51 -080099 RSExportable *RSE = *I;
100 if (RSE->getKind() != RSExportable::EX_TYPE)
Zonr Chang641558f2010-10-12 21:07:06 +0800101 continue;
102
Stephen Hinesa858cb62011-01-17 12:17:51 -0800103 RSExportType *ET = static_cast<RSExportType *>(RSE);
Zonr Chang641558f2010-10-12 21:07:06 +0800104 if (ET->getClass() != RSExportType::ExportClassRecord)
105 continue;
106
107 RSExportRecordType *ERT = static_cast<RSExportRecordType *>(ET);
108
109 // Artificial record types (create by us not by user in the source) always
110 // conforms the ODR.
111 if (ERT->isArtificial())
112 continue;
113
114 // Key to lookup ERT in ReflectedDefinitions
115 llvm::StringRef RDKey(ERT->getName());
116 ReflectedDefinitionListTy::const_iterator RD =
117 ReflectedDefinitions.find(RDKey);
118
119 if (RD != ReflectedDefinitions.end()) {
120 const RSExportRecordType *Reflected = RD->getValue().first;
121 // There's a record (struct) with the same name reflected before. Enforce
122 // ODR checking - the Reflected must hold *exactly* the same "definition"
123 // as the one defined previously. We say two record types A and B have the
124 // same definition iff:
125 //
126 // struct A { struct B {
127 // Type(a1) a1, Type(b1) b1,
128 // Type(a2) a2, Type(b1) b2,
129 // ... ...
130 // Type(aN) aN Type(b3) b3,
131 // }; }
132 // Cond. #1. They have same number of fields, i.e., N = M;
133 // Cond. #2. for (i := 1 to N)
134 // Type(ai) = Type(bi) must hold;
135 // Cond. #3. for (i := 1 to N)
136 // Name(ai) = Name(bi) must hold;
137 //
138 // where,
139 // Type(F) = the type of field F and
140 // Name(F) = the field name.
141
142 bool PassODR = false;
143 // Cond. #1 and Cond. #2
144 if (Reflected->equals(ERT)) {
145 // Cond #3.
146 RSExportRecordType::const_field_iterator AI = Reflected->fields_begin(),
147 BI = ERT->fields_begin();
148
149 for (unsigned i = 0, e = Reflected->getFields().size(); i != e; i++) {
150 if ((*AI)->getName() != (*BI)->getName())
151 break;
152 AI++;
153 BI++;
154 }
155 PassODR = (AI == (Reflected->fields_end()));
156 }
157
158 if (!PassODR) {
159 getDiagnostics().Report(mDiagErrorODR) << Reflected->getName()
160 << getInputFileName()
161 << RD->getValue().second;
162 return false;
163 }
164 } else {
165 llvm::StringMapEntry<ReflectedDefinitionTy> *ME =
166 llvm::StringMapEntry<ReflectedDefinitionTy>::Create(RDKey.begin(),
167 RDKey.end());
Zonr Change86245a2010-10-12 21:42:13 +0800168 ME->setValue(std::make_pair(ERT, CurInputFile));
Zonr Chang641558f2010-10-12 21:07:06 +0800169
170 if (!ReflectedDefinitions.insert(ME))
171 delete ME;
172
173 // Take the ownership of ERT such that it won't be freed in ~RSContext().
174 ERT->keep();
175 }
Zonr Chang641558f2010-10-12 21:07:06 +0800176 }
177 return true;
178}
Zonr Changcf6af6a2010-10-12 12:38:51 +0800179
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800180void SlangRS::initDiagnostic() {
Logan Chien9207a2e2011-10-21 15:39:28 +0800181 clang::DiagnosticsEngine &DiagEngine = getDiagnostics();
Zonr Changcf6af6a2010-10-12 12:38:51 +0800182
Logan Chien9207a2e2011-10-21 15:39:28 +0800183 if (DiagEngine.setDiagnosticGroupMapping("implicit-function-declaration",
184 clang::diag::MAP_ERROR))
185 DiagEngine.Report(clang::diag::warn_unknown_warning_option)
186 << "implicit-function-declaration";
187
188 DiagEngine.setDiagnosticMapping(
189 clang::diag::ext_typecheck_convert_discards_qualifiers,
190 clang::diag::MAP_ERROR,
191 clang::SourceLocation());
Zonr Chang641558f2010-10-12 21:07:06 +0800192
193 mDiagErrorInvalidOutputDepParameter =
Logan Chien9207a2e2011-10-21 15:39:28 +0800194 DiagEngine.getCustomDiagID(
195 clang::DiagnosticsEngine::Error,
196 "invalid parameter for output dependencies files.");
Zonr Chang641558f2010-10-12 21:07:06 +0800197
198 mDiagErrorODR =
Logan Chien9207a2e2011-10-21 15:39:28 +0800199 DiagEngine.getCustomDiagID(
200 clang::DiagnosticsEngine::Error,
201 "type '%0' in different translation unit (%1 v.s. %2) "
202 "has incompatible type definition");
Zonr Chang641558f2010-10-12 21:07:06 +0800203
Logan Chien9207a2e2011-10-21 15:39:28 +0800204 mDiagErrorTargetAPIRange =
205 DiagEngine.getCustomDiagID(
206 clang::DiagnosticsEngine::Error,
Stephen Hines2e35b132011-07-22 02:50:19 -0700207 "target API level '%0' is out of range ('%1' - '%2')");
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800208}
209
210void SlangRS::initPreprocessor() {
211 clang::Preprocessor &PP = getPreprocessor();
212
Stephen Hines2e35b132011-07-22 02:50:19 -0700213 std::stringstream RSH;
Stephen Hines0e4ee652014-06-10 14:32:26 -0700214 RSH << PP.getPredefines();
Jean-Luc Brouillet29689212014-05-27 13:25:31 -0700215 RSH << "#define RS_VERSION " << mTargetAPI << "\n";
216 RSH << "#include \"rs_core." RS_HEADER_SUFFIX "\"\n";
Stephen Hines2e35b132011-07-22 02:50:19 -0700217 PP.setPredefines(RSH.str());
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800218}
219
220void SlangRS::initASTContext() {
Stephen Hines9e5b5032010-11-03 13:19:14 -0700221 mRSContext = new RSContext(getPreprocessor(),
222 getASTContext(),
Stephen Hines3fd0a942011-01-18 12:27:39 -0800223 getTargetInfo(),
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800224 &mPragmas,
Jean-Luc Brouillet12fc2832014-06-04 21:32:31 +0000225 mTargetAPI);
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800226}
227
228clang::ASTConsumer
229*SlangRS::createBackend(const clang::CodeGenOptions& CodeGenOpts,
230 llvm::raw_ostream *OS,
231 Slang::OutputType OT) {
232 return new RSBackend(mRSContext,
Stephen Hinese639eb52010-11-08 19:27:20 -0800233 &getDiagnostics(),
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800234 CodeGenOpts,
235 getTargetOptions(),
Stephen Hines3fd0a942011-01-18 12:27:39 -0800236 &mPragmas,
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800237 OS,
238 OT,
239 getSourceManager(),
Stephen Hines11274a72012-09-26 19:14:20 -0700240 mAllowRSPrefix,
241 mIsFilterscript);
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800242}
243
Zonr Chang592a9542010-10-07 20:03:58 +0800244bool SlangRS::IsRSHeaderFile(const char *File) {
Stephen Hines2d35edd2011-08-09 11:33:27 -0700245#define RS_HEADER_ENTRY(name) \
Tim Murrayee4016d2014-04-10 15:49:08 -0700246 if (::strcmp(File, #name "." RS_HEADER_SUFFIX) == 0) \
Zonr Chang592a9542010-10-07 20:03:58 +0800247 return true;
248ENUM_RS_HEADER()
249#undef RS_HEADER_ENTRY
Zonr Chang592a9542010-10-07 20:03:58 +0800250 return false;
251}
252
Stephen Hines11274a72012-09-26 19:14:20 -0700253bool SlangRS::IsLocInRSHeaderFile(const clang::SourceLocation &Loc,
254 const clang::SourceManager &SourceMgr) {
255 clang::FullSourceLoc FSL(Loc, SourceMgr);
Stephen Hinesfcda2352010-10-19 16:49:32 -0700256 clang::PresumedLoc PLoc = SourceMgr.getPresumedLoc(FSL);
Stephen Hinesfcda2352010-10-19 16:49:32 -0700257
Stephen Hines688e64b2011-08-23 16:01:25 -0700258 const char *Filename = PLoc.getFilename();
259 if (!Filename) {
260 return false;
261 } else {
262 return IsRSHeaderFile(llvm::sys::path::filename(Filename).data());
263 }
Stephen Hinesfcda2352010-10-19 16:49:32 -0700264}
265
Logan Chien9207a2e2011-10-21 15:39:28 +0800266SlangRS::SlangRS()
Stephen Hines11274a72012-09-26 19:14:20 -0700267 : Slang(), mRSContext(NULL), mAllowRSPrefix(false), mTargetAPI(0),
268 mIsFilterscript(false) {
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800269}
270
Zonr Changcf6af6a2010-10-12 12:38:51 +0800271bool SlangRS::compile(
272 const std::list<std::pair<const char*, const char*> > &IOFiles,
273 const std::list<std::pair<const char*, const char*> > &DepFiles,
Stephen Hines7f5704e2014-06-10 18:06:50 -0700274 const RSCCOptions &Opts) {
Zonr Changcf6af6a2010-10-12 12:38:51 +0800275 if (IOFiles.empty())
276 return true;
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800277
Stephen Hines7f5704e2014-06-10 18:06:50 -0700278 if (Opts.mEmitDependency && (DepFiles.size() != IOFiles.size())) {
Zonr Chang641558f2010-10-12 21:07:06 +0800279 getDiagnostics().Report(mDiagErrorInvalidOutputDepParameter);
Zonr Changcf6af6a2010-10-12 12:38:51 +0800280 return false;
281 }
282
283 std::string RealPackageName;
284
285 const char *InputFile, *OutputFile, *BCOutputFile, *DepOutputFile;
286 std::list<std::pair<const char*, const char*> >::const_iterator
287 IOFileIter = IOFiles.begin(), DepFileIter = DepFiles.begin();
288
Stephen Hines7f5704e2014-06-10 18:06:50 -0700289 setIncludePaths(Opts.mIncludePaths);
290 setOutputType(Opts.mOutputType);
291 if (Opts.mEmitDependency) {
292 setAdditionalDepTargets(Opts.mAdditionalDepTargets);
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800293 }
Zonr Changcf6af6a2010-10-12 12:38:51 +0800294
Stephen Hines7f5704e2014-06-10 18:06:50 -0700295 setDebugMetadataEmission(Opts.mDebugEmission);
mkopec1c460b372012-01-09 11:21:50 -0500296
Stephen Hines7f5704e2014-06-10 18:06:50 -0700297 setOptimizationLevel(Opts.mOptimizationLevel);
mkopec1c460b372012-01-09 11:21:50 -0500298
Stephen Hines7f5704e2014-06-10 18:06:50 -0700299 mAllowRSPrefix = Opts.mAllowRSPrefix;
Zonr Changcf6af6a2010-10-12 12:38:51 +0800300
Stephen Hines7f5704e2014-06-10 18:06:50 -0700301 mTargetAPI = Opts.mTargetAPI;
Stephen Hines4cc499d2011-08-24 19:06:17 -0700302 if (mTargetAPI < SLANG_MINIMUM_TARGET_API ||
303 mTargetAPI > SLANG_MAXIMUM_TARGET_API) {
Stephen Hines2e35b132011-07-22 02:50:19 -0700304 getDiagnostics().Report(mDiagErrorTargetAPIRange) << mTargetAPI
Stephen Hines4cc499d2011-08-24 19:06:17 -0700305 << SLANG_MINIMUM_TARGET_API << SLANG_MAXIMUM_TARGET_API;
Stephen Hines2e35b132011-07-22 02:50:19 -0700306 return false;
307 }
308
Stephen Hinesc632be22011-09-23 15:53:16 -0700309 // Skip generation of warnings a second time if we are doing more than just
310 // a single pass over the input file.
Stephen Hines7f5704e2014-06-10 18:06:50 -0700311 bool SuppressAllWarnings = (Opts.mOutputType != Slang::OT_Dependency);
Stephen Hinesc632be22011-09-23 15:53:16 -0700312
Zonr Changcf6af6a2010-10-12 12:38:51 +0800313 for (unsigned i = 0, e = IOFiles.size(); i != e; i++) {
314 InputFile = IOFileIter->first;
315 OutputFile = IOFileIter->second;
316
317 reset();
318
319 if (!setInputSource(InputFile))
320 return false;
321
322 if (!setOutput(OutputFile))
323 return false;
324
Stephen Hines11274a72012-09-26 19:14:20 -0700325 mIsFilterscript = isFilterscript(InputFile);
326
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800327 if (Slang::compile() > 0)
328 return false;
329
Stephen Hines7f5704e2014-06-10 18:06:50 -0700330 if (!Opts.mJavaReflectionPackageName.empty()) {
331 mRSContext->setReflectJavaPackageName(Opts.mJavaReflectionPackageName);
Stephen Hines925879f2013-07-19 18:19:04 -0700332 }
333 const std::string &RealPackageName =
334 mRSContext->getReflectJavaPackageName();
335
Stephen Hines7f5704e2014-06-10 18:06:50 -0700336 if (Opts.mOutputType != Slang::OT_Dependency) {
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800337
Stephen Hines7f5704e2014-06-10 18:06:50 -0700338 if (Opts.mBitcodeStorage == BCST_CPP_CODE) {
339 RSReflectionCpp R(mRSContext, Opts.mJavaReflectionPathBase,
340 getInputFileName(), getOutputFileName());
Jean-Luc Brouillet59f22c32014-06-04 14:53:48 -0700341 if (!R.reflect()) {
Jason Sams1b6a0882012-03-12 15:07:58 -0700342 return false;
343 }
Stephen Hines5c25c512012-02-27 12:58:17 -0800344 } else {
Stephen Hines7f5704e2014-06-10 18:06:50 -0700345 if (!Opts.mRSPackageName.empty()) {
346 mRSContext->setRSPackageName(Opts.mRSPackageName);
Jean-Luc Brouillet12fc2832014-06-04 21:32:31 +0000347 }
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800348
Jean-Luc Brouillet59f22c32014-06-04 14:53:48 -0700349 RSReflectionJava R(mRSContext, &mGeneratedFileNames,
Stephen Hines7f5704e2014-06-10 18:06:50 -0700350 Opts.mJavaReflectionPathBase, getInputFileName(),
Jean-Luc Brouillet59f22c32014-06-04 14:53:48 -0700351 getOutputFileName(),
Stephen Hines7f5704e2014-06-10 18:06:50 -0700352 Opts.mBitcodeStorage == BCST_JAVA_CODE);
Jean-Luc Brouillet59f22c32014-06-04 14:53:48 -0700353 if (!R.reflect()) {
Jean-Luc Brouillet12fc2832014-06-04 21:32:31 +0000354 // TODO Is this needed or will the error message have been printed
355 // already? and why not for the C++ case?
356 fprintf(stderr, "RSContext::reflectToJava : failed to do reflection "
357 "(%s)\n",
358 R.getLastError());
Jean-Luc Brouillet7fda9842014-06-04 19:23:55 +0000359 return false;
Stephen Hines5c25c512012-02-27 12:58:17 -0800360 }
361
362 for (std::vector<std::string>::const_iterator
363 I = mGeneratedFileNames.begin(), E = mGeneratedFileNames.end();
364 I != E;
365 I++) {
366 std::string ReflectedName = RSSlangReflectUtils::ComputePackagedPath(
Stephen Hines7f5704e2014-06-10 18:06:50 -0700367 Opts.mJavaReflectionPathBase.c_str(),
Stephen Hines5c25c512012-02-27 12:58:17 -0800368 (RealPackageName + OS_PATH_SEPARATOR_STR + *I).c_str());
369 appendGeneratedFileName(ReflectedName + ".java");
370 }
371
Stephen Hines7f5704e2014-06-10 18:06:50 -0700372 if ((Opts.mOutputType == Slang::OT_Bitcode) &&
373 (Opts.mBitcodeStorage == BCST_JAVA_CODE) &&
374 !generateJavaBitcodeAccessor(Opts.mJavaReflectionPathBase,
Jean-Luc Brouillet129fd822014-05-28 17:46:10 -0700375 RealPackageName.c_str(),
376 mRSContext->getLicenseNote())) {
Stephen Hines5c25c512012-02-27 12:58:17 -0800377 return false;
378 }
379 }
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800380 }
381
Stephen Hines7f5704e2014-06-10 18:06:50 -0700382 if (Opts.mEmitDependency) {
Zonr Changcf6af6a2010-10-12 12:38:51 +0800383 BCOutputFile = DepFileIter->first;
384 DepOutputFile = DepFileIter->second;
385
386 setDepTargetBC(BCOutputFile);
387
388 if (!setDepOutput(DepOutputFile))
389 return false;
390
Stephen Hinesc632be22011-09-23 15:53:16 -0700391 if (SuppressAllWarnings) {
392 getDiagnostics().setSuppressAllDiagnostics(true);
393 }
Zonr Changcf6af6a2010-10-12 12:38:51 +0800394 if (generateDepFile() > 0)
395 return false;
Stephen Hinesc632be22011-09-23 15:53:16 -0700396 if (SuppressAllWarnings) {
397 getDiagnostics().setSuppressAllDiagnostics(false);
398 }
Zonr Changcf6af6a2010-10-12 12:38:51 +0800399
400 DepFileIter++;
401 }
402
Zonr Change86245a2010-10-12 21:42:13 +0800403 if (!checkODR(InputFile))
Zonr Chang641558f2010-10-12 21:07:06 +0800404 return false;
405
Zonr Changcf6af6a2010-10-12 12:38:51 +0800406 IOFileIter++;
407 }
408
409 return true;
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800410}
411
Zonr Chang641558f2010-10-12 21:07:06 +0800412void SlangRS::reset() {
413 delete mRSContext;
414 mRSContext = NULL;
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800415 mGeneratedFileNames.clear();
Zonr Chang641558f2010-10-12 21:07:06 +0800416 Slang::reset();
Zonr Chang641558f2010-10-12 21:07:06 +0800417}
418
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800419SlangRS::~SlangRS() {
420 delete mRSContext;
Zonr Chang641558f2010-10-12 21:07:06 +0800421 for (ReflectedDefinitionListTy::iterator I = ReflectedDefinitions.begin(),
422 E = ReflectedDefinitions.end();
423 I != E;
424 I++) {
425 delete I->getValue().first;
426 }
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800427}
Stephen Hinese639eb52010-11-08 19:27:20 -0800428
429} // namespace slang