blob: bc469729fb322918edaec679a5fe7c4b98a010ec [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();
Stephen Hines9ae18b22014-06-10 23:53:00 -070085 BCAccessorContext.bc32FileName = getOutput32FileName().c_str();
86 BCAccessorContext.bc64FileName = getOutputFileName().c_str();
Zonr Changcf6af6a2010-10-12 12:38:51 +080087 BCAccessorContext.reflectPath = OutputPathBase.c_str();
88 BCAccessorContext.packageName = PackageName.c_str();
Jean-Luc Brouillet129fd822014-05-28 17:46:10 -070089 BCAccessorContext.licenseNote = LicenseNote;
Zonr Changcf6af6a2010-10-12 12:38:51 +080090 BCAccessorContext.bcStorage = BCST_JAVA_CODE; // Must be BCST_JAVA_CODE
Stephen Hines9ae18b22014-06-10 23:53:00 -070091 BCAccessorContext.verbose = false;
Zonr Changcf6af6a2010-10-12 12:38:51 +080092
Jean-Luc Brouillet129fd822014-05-28 17:46:10 -070093 return RSSlangReflectUtils::GenerateJavaBitCodeAccessor(BCAccessorContext);
Zonr Changcf6af6a2010-10-12 12:38:51 +080094}
95
Zonr Change86245a2010-10-12 21:42:13 +080096bool SlangRS::checkODR(const char *CurInputFile) {
Zonr Chang641558f2010-10-12 21:07:06 +080097 for (RSContext::ExportableList::iterator I = mRSContext->exportable_begin(),
98 E = mRSContext->exportable_end();
99 I != E;
100 I++) {
Stephen Hinesa858cb62011-01-17 12:17:51 -0800101 RSExportable *RSE = *I;
102 if (RSE->getKind() != RSExportable::EX_TYPE)
Zonr Chang641558f2010-10-12 21:07:06 +0800103 continue;
104
Stephen Hinesa858cb62011-01-17 12:17:51 -0800105 RSExportType *ET = static_cast<RSExportType *>(RSE);
Zonr Chang641558f2010-10-12 21:07:06 +0800106 if (ET->getClass() != RSExportType::ExportClassRecord)
107 continue;
108
109 RSExportRecordType *ERT = static_cast<RSExportRecordType *>(ET);
110
111 // Artificial record types (create by us not by user in the source) always
112 // conforms the ODR.
113 if (ERT->isArtificial())
114 continue;
115
116 // Key to lookup ERT in ReflectedDefinitions
117 llvm::StringRef RDKey(ERT->getName());
118 ReflectedDefinitionListTy::const_iterator RD =
119 ReflectedDefinitions.find(RDKey);
120
121 if (RD != ReflectedDefinitions.end()) {
122 const RSExportRecordType *Reflected = RD->getValue().first;
123 // There's a record (struct) with the same name reflected before. Enforce
124 // ODR checking - the Reflected must hold *exactly* the same "definition"
125 // as the one defined previously. We say two record types A and B have the
126 // same definition iff:
127 //
128 // struct A { struct B {
129 // Type(a1) a1, Type(b1) b1,
130 // Type(a2) a2, Type(b1) b2,
131 // ... ...
132 // Type(aN) aN Type(b3) b3,
133 // }; }
134 // Cond. #1. They have same number of fields, i.e., N = M;
135 // Cond. #2. for (i := 1 to N)
136 // Type(ai) = Type(bi) must hold;
137 // Cond. #3. for (i := 1 to N)
138 // Name(ai) = Name(bi) must hold;
139 //
140 // where,
141 // Type(F) = the type of field F and
142 // Name(F) = the field name.
143
144 bool PassODR = false;
145 // Cond. #1 and Cond. #2
146 if (Reflected->equals(ERT)) {
147 // Cond #3.
148 RSExportRecordType::const_field_iterator AI = Reflected->fields_begin(),
149 BI = ERT->fields_begin();
150
151 for (unsigned i = 0, e = Reflected->getFields().size(); i != e; i++) {
152 if ((*AI)->getName() != (*BI)->getName())
153 break;
154 AI++;
155 BI++;
156 }
157 PassODR = (AI == (Reflected->fields_end()));
158 }
159
160 if (!PassODR) {
161 getDiagnostics().Report(mDiagErrorODR) << Reflected->getName()
162 << getInputFileName()
163 << RD->getValue().second;
164 return false;
165 }
166 } else {
167 llvm::StringMapEntry<ReflectedDefinitionTy> *ME =
168 llvm::StringMapEntry<ReflectedDefinitionTy>::Create(RDKey.begin(),
169 RDKey.end());
Zonr Change86245a2010-10-12 21:42:13 +0800170 ME->setValue(std::make_pair(ERT, CurInputFile));
Zonr Chang641558f2010-10-12 21:07:06 +0800171
172 if (!ReflectedDefinitions.insert(ME))
173 delete ME;
174
175 // Take the ownership of ERT such that it won't be freed in ~RSContext().
176 ERT->keep();
177 }
Zonr Chang641558f2010-10-12 21:07:06 +0800178 }
179 return true;
180}
Zonr Changcf6af6a2010-10-12 12:38:51 +0800181
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800182void SlangRS::initDiagnostic() {
Logan Chien9207a2e2011-10-21 15:39:28 +0800183 clang::DiagnosticsEngine &DiagEngine = getDiagnostics();
Zonr Changcf6af6a2010-10-12 12:38:51 +0800184
Logan Chien9207a2e2011-10-21 15:39:28 +0800185 if (DiagEngine.setDiagnosticGroupMapping("implicit-function-declaration",
186 clang::diag::MAP_ERROR))
187 DiagEngine.Report(clang::diag::warn_unknown_warning_option)
188 << "implicit-function-declaration";
189
190 DiagEngine.setDiagnosticMapping(
191 clang::diag::ext_typecheck_convert_discards_qualifiers,
192 clang::diag::MAP_ERROR,
193 clang::SourceLocation());
Zonr Chang641558f2010-10-12 21:07:06 +0800194
195 mDiagErrorInvalidOutputDepParameter =
Logan Chien9207a2e2011-10-21 15:39:28 +0800196 DiagEngine.getCustomDiagID(
197 clang::DiagnosticsEngine::Error,
198 "invalid parameter for output dependencies files.");
Zonr Chang641558f2010-10-12 21:07:06 +0800199
200 mDiagErrorODR =
Logan Chien9207a2e2011-10-21 15:39:28 +0800201 DiagEngine.getCustomDiagID(
202 clang::DiagnosticsEngine::Error,
203 "type '%0' in different translation unit (%1 v.s. %2) "
204 "has incompatible type definition");
Zonr Chang641558f2010-10-12 21:07:06 +0800205
Logan Chien9207a2e2011-10-21 15:39:28 +0800206 mDiagErrorTargetAPIRange =
207 DiagEngine.getCustomDiagID(
208 clang::DiagnosticsEngine::Error,
Stephen Hines2e35b132011-07-22 02:50:19 -0700209 "target API level '%0' is out of range ('%1' - '%2')");
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800210}
211
212void SlangRS::initPreprocessor() {
213 clang::Preprocessor &PP = getPreprocessor();
214
Stephen Hines2e35b132011-07-22 02:50:19 -0700215 std::stringstream RSH;
Stephen Hines0e4ee652014-06-10 14:32:26 -0700216 RSH << PP.getPredefines();
Jean-Luc Brouillet29689212014-05-27 13:25:31 -0700217 RSH << "#define RS_VERSION " << mTargetAPI << "\n";
218 RSH << "#include \"rs_core." RS_HEADER_SUFFIX "\"\n";
Stephen Hines2e35b132011-07-22 02:50:19 -0700219 PP.setPredefines(RSH.str());
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800220}
221
222void SlangRS::initASTContext() {
Stephen Hines9e5b5032010-11-03 13:19:14 -0700223 mRSContext = new RSContext(getPreprocessor(),
224 getASTContext(),
Stephen Hines3fd0a942011-01-18 12:27:39 -0800225 getTargetInfo(),
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800226 &mPragmas,
Stephen Hinesfc4f78b2014-06-10 18:07:10 -0700227 mTargetAPI,
228 mVerbose);
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800229}
230
231clang::ASTConsumer
232*SlangRS::createBackend(const clang::CodeGenOptions& CodeGenOpts,
233 llvm::raw_ostream *OS,
234 Slang::OutputType OT) {
235 return new RSBackend(mRSContext,
Stephen Hinese639eb52010-11-08 19:27:20 -0800236 &getDiagnostics(),
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800237 CodeGenOpts,
238 getTargetOptions(),
Stephen Hines3fd0a942011-01-18 12:27:39 -0800239 &mPragmas,
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800240 OS,
241 OT,
242 getSourceManager(),
Stephen Hines11274a72012-09-26 19:14:20 -0700243 mAllowRSPrefix,
244 mIsFilterscript);
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800245}
246
Zonr Chang592a9542010-10-07 20:03:58 +0800247bool SlangRS::IsRSHeaderFile(const char *File) {
Stephen Hines2d35edd2011-08-09 11:33:27 -0700248#define RS_HEADER_ENTRY(name) \
Tim Murrayee4016d2014-04-10 15:49:08 -0700249 if (::strcmp(File, #name "." RS_HEADER_SUFFIX) == 0) \
Zonr Chang592a9542010-10-07 20:03:58 +0800250 return true;
251ENUM_RS_HEADER()
252#undef RS_HEADER_ENTRY
Zonr Chang592a9542010-10-07 20:03:58 +0800253 return false;
254}
255
Stephen Hines11274a72012-09-26 19:14:20 -0700256bool SlangRS::IsLocInRSHeaderFile(const clang::SourceLocation &Loc,
257 const clang::SourceManager &SourceMgr) {
258 clang::FullSourceLoc FSL(Loc, SourceMgr);
Stephen Hinesfcda2352010-10-19 16:49:32 -0700259 clang::PresumedLoc PLoc = SourceMgr.getPresumedLoc(FSL);
Stephen Hinesfcda2352010-10-19 16:49:32 -0700260
Stephen Hines688e64b2011-08-23 16:01:25 -0700261 const char *Filename = PLoc.getFilename();
262 if (!Filename) {
263 return false;
264 } else {
265 return IsRSHeaderFile(llvm::sys::path::filename(Filename).data());
266 }
Stephen Hinesfcda2352010-10-19 16:49:32 -0700267}
268
Logan Chien9207a2e2011-10-21 15:39:28 +0800269SlangRS::SlangRS()
Stephen Hines11274a72012-09-26 19:14:20 -0700270 : Slang(), mRSContext(NULL), mAllowRSPrefix(false), mTargetAPI(0),
Stephen Hinesfc4f78b2014-06-10 18:07:10 -0700271 mVerbose(false), mIsFilterscript(false) {
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800272}
273
Zonr Changcf6af6a2010-10-12 12:38:51 +0800274bool SlangRS::compile(
Stephen Hines9ae18b22014-06-10 23:53:00 -0700275 const std::list<std::pair<const char*, const char*> > &IOFiles64,
276 const std::list<std::pair<const char*, const char*> > &IOFiles32,
Zonr Changcf6af6a2010-10-12 12:38:51 +0800277 const std::list<std::pair<const char*, const char*> > &DepFiles,
Stephen Hines7f5704e2014-06-10 18:06:50 -0700278 const RSCCOptions &Opts) {
Stephen Hines9ae18b22014-06-10 23:53:00 -0700279 if (IOFiles32.empty())
Zonr Changcf6af6a2010-10-12 12:38:51 +0800280 return true;
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800281
Stephen Hines9ae18b22014-06-10 23:53:00 -0700282 if (Opts.mEmitDependency && (DepFiles.size() != IOFiles32.size())) {
Zonr Chang641558f2010-10-12 21:07:06 +0800283 getDiagnostics().Report(mDiagErrorInvalidOutputDepParameter);
Zonr Changcf6af6a2010-10-12 12:38:51 +0800284 return false;
285 }
286
Stephen Hines9ae18b22014-06-10 23:53:00 -0700287 if (Opts.mEmit3264 && (IOFiles64.size() != IOFiles32.size())) {
288 slangAssert(false && "Should have equal number of 32/64-bit files");
289 return false;
290 }
291
Zonr Changcf6af6a2010-10-12 12:38:51 +0800292 std::string RealPackageName;
293
Stephen Hines9ae18b22014-06-10 23:53:00 -0700294 const char *InputFile, *Output64File, *Output32File, *BCOutputFile,
295 *DepOutputFile;
Zonr Changcf6af6a2010-10-12 12:38:51 +0800296 std::list<std::pair<const char*, const char*> >::const_iterator
Stephen Hines9ae18b22014-06-10 23:53:00 -0700297 IOFile64Iter = IOFiles64.begin(),
298 IOFile32Iter = IOFiles32.begin(),
299 DepFileIter = DepFiles.begin();
Zonr Changcf6af6a2010-10-12 12:38:51 +0800300
Stephen Hines7f5704e2014-06-10 18:06:50 -0700301 setIncludePaths(Opts.mIncludePaths);
302 setOutputType(Opts.mOutputType);
303 if (Opts.mEmitDependency) {
304 setAdditionalDepTargets(Opts.mAdditionalDepTargets);
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800305 }
Zonr Changcf6af6a2010-10-12 12:38:51 +0800306
Stephen Hines7f5704e2014-06-10 18:06:50 -0700307 setDebugMetadataEmission(Opts.mDebugEmission);
mkopec1c460b372012-01-09 11:21:50 -0500308
Stephen Hines7f5704e2014-06-10 18:06:50 -0700309 setOptimizationLevel(Opts.mOptimizationLevel);
mkopec1c460b372012-01-09 11:21:50 -0500310
Stephen Hines7f5704e2014-06-10 18:06:50 -0700311 mAllowRSPrefix = Opts.mAllowRSPrefix;
Zonr Changcf6af6a2010-10-12 12:38:51 +0800312
Stephen Hines7f5704e2014-06-10 18:06:50 -0700313 mTargetAPI = Opts.mTargetAPI;
Chris Wailes9e3aa072014-06-16 18:52:02 -0700314 if (mTargetAPI != SLANG_DEVELOPMENT_TARGET_API &&
315 (mTargetAPI < SLANG_MINIMUM_TARGET_API ||
316 mTargetAPI > SLANG_MAXIMUM_TARGET_API)) {
Stephen Hines2e35b132011-07-22 02:50:19 -0700317 getDiagnostics().Report(mDiagErrorTargetAPIRange) << mTargetAPI
Stephen Hines4cc499d2011-08-24 19:06:17 -0700318 << SLANG_MINIMUM_TARGET_API << SLANG_MAXIMUM_TARGET_API;
Stephen Hines2e35b132011-07-22 02:50:19 -0700319 return false;
320 }
321
Stephen Hinesfc4f78b2014-06-10 18:07:10 -0700322 mVerbose = Opts.mVerbose;
323
Stephen Hinesc632be22011-09-23 15:53:16 -0700324 // Skip generation of warnings a second time if we are doing more than just
325 // a single pass over the input file.
Stephen Hines7f5704e2014-06-10 18:06:50 -0700326 bool SuppressAllWarnings = (Opts.mOutputType != Slang::OT_Dependency);
Stephen Hinesc632be22011-09-23 15:53:16 -0700327
Stephen Hines9ae18b22014-06-10 23:53:00 -0700328 for (unsigned i = 0, e = IOFiles32.size(); i != e; i++) {
329 InputFile = IOFile64Iter->first;
330 Output64File = IOFile64Iter->second;
331 Output32File = IOFile32Iter->second;
Zonr Changcf6af6a2010-10-12 12:38:51 +0800332
333 reset();
334
335 if (!setInputSource(InputFile))
336 return false;
337
Stephen Hines9ae18b22014-06-10 23:53:00 -0700338 if (!setOutput(Output64File))
Zonr Changcf6af6a2010-10-12 12:38:51 +0800339 return false;
340
Stephen Hines9ae18b22014-06-10 23:53:00 -0700341 setOutput32(Output32File);
342
Stephen Hines11274a72012-09-26 19:14:20 -0700343 mIsFilterscript = isFilterscript(InputFile);
344
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800345 if (Slang::compile() > 0)
346 return false;
347
Stephen Hines7f5704e2014-06-10 18:06:50 -0700348 if (!Opts.mJavaReflectionPackageName.empty()) {
349 mRSContext->setReflectJavaPackageName(Opts.mJavaReflectionPackageName);
Stephen Hines925879f2013-07-19 18:19:04 -0700350 }
351 const std::string &RealPackageName =
352 mRSContext->getReflectJavaPackageName();
353
Stephen Hines9ae18b22014-06-10 23:53:00 -0700354 bool doReflection = true;
355 if (Opts.mEmit3264 && (Opts.mBitWidth == 32)) {
356 // Skip reflection on the 32-bit path if we are going to emit it on the
357 // 64-bit path.
358 doReflection = false;
359 }
360 if (Opts.mOutputType != Slang::OT_Dependency && doReflection) {
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800361
Stephen Hines7f5704e2014-06-10 18:06:50 -0700362 if (Opts.mBitcodeStorage == BCST_CPP_CODE) {
363 RSReflectionCpp R(mRSContext, Opts.mJavaReflectionPathBase,
364 getInputFileName(), getOutputFileName());
Jean-Luc Brouillet59f22c32014-06-04 14:53:48 -0700365 if (!R.reflect()) {
Jason Sams1b6a0882012-03-12 15:07:58 -0700366 return false;
367 }
Stephen Hines5c25c512012-02-27 12:58:17 -0800368 } else {
Stephen Hines7f5704e2014-06-10 18:06:50 -0700369 if (!Opts.mRSPackageName.empty()) {
370 mRSContext->setRSPackageName(Opts.mRSPackageName);
Jean-Luc Brouillet12fc2832014-06-04 21:32:31 +0000371 }
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800372
Jean-Luc Brouillet59f22c32014-06-04 14:53:48 -0700373 RSReflectionJava R(mRSContext, &mGeneratedFileNames,
Stephen Hines7f5704e2014-06-10 18:06:50 -0700374 Opts.mJavaReflectionPathBase, getInputFileName(),
Jean-Luc Brouillet59f22c32014-06-04 14:53:48 -0700375 getOutputFileName(),
Stephen Hines7f5704e2014-06-10 18:06:50 -0700376 Opts.mBitcodeStorage == BCST_JAVA_CODE);
Jean-Luc Brouillet59f22c32014-06-04 14:53:48 -0700377 if (!R.reflect()) {
Jean-Luc Brouillet12fc2832014-06-04 21:32:31 +0000378 // TODO Is this needed or will the error message have been printed
379 // already? and why not for the C++ case?
380 fprintf(stderr, "RSContext::reflectToJava : failed to do reflection "
381 "(%s)\n",
382 R.getLastError());
Jean-Luc Brouillet7fda9842014-06-04 19:23:55 +0000383 return false;
Stephen Hines5c25c512012-02-27 12:58:17 -0800384 }
385
386 for (std::vector<std::string>::const_iterator
387 I = mGeneratedFileNames.begin(), E = mGeneratedFileNames.end();
388 I != E;
389 I++) {
390 std::string ReflectedName = RSSlangReflectUtils::ComputePackagedPath(
Stephen Hines7f5704e2014-06-10 18:06:50 -0700391 Opts.mJavaReflectionPathBase.c_str(),
Stephen Hines5c25c512012-02-27 12:58:17 -0800392 (RealPackageName + OS_PATH_SEPARATOR_STR + *I).c_str());
393 appendGeneratedFileName(ReflectedName + ".java");
394 }
395
Stephen Hines7f5704e2014-06-10 18:06:50 -0700396 if ((Opts.mOutputType == Slang::OT_Bitcode) &&
397 (Opts.mBitcodeStorage == BCST_JAVA_CODE) &&
398 !generateJavaBitcodeAccessor(Opts.mJavaReflectionPathBase,
Jean-Luc Brouillet129fd822014-05-28 17:46:10 -0700399 RealPackageName.c_str(),
400 mRSContext->getLicenseNote())) {
Stephen Hines5c25c512012-02-27 12:58:17 -0800401 return false;
402 }
403 }
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800404 }
405
Stephen Hines7f5704e2014-06-10 18:06:50 -0700406 if (Opts.mEmitDependency) {
Zonr Changcf6af6a2010-10-12 12:38:51 +0800407 BCOutputFile = DepFileIter->first;
408 DepOutputFile = DepFileIter->second;
409
410 setDepTargetBC(BCOutputFile);
411
412 if (!setDepOutput(DepOutputFile))
413 return false;
414
Stephen Hinesc632be22011-09-23 15:53:16 -0700415 if (SuppressAllWarnings) {
416 getDiagnostics().setSuppressAllDiagnostics(true);
417 }
Zonr Changcf6af6a2010-10-12 12:38:51 +0800418 if (generateDepFile() > 0)
419 return false;
Stephen Hinesc632be22011-09-23 15:53:16 -0700420 if (SuppressAllWarnings) {
421 getDiagnostics().setSuppressAllDiagnostics(false);
422 }
Zonr Changcf6af6a2010-10-12 12:38:51 +0800423
424 DepFileIter++;
425 }
426
Zonr Change86245a2010-10-12 21:42:13 +0800427 if (!checkODR(InputFile))
Zonr Chang641558f2010-10-12 21:07:06 +0800428 return false;
429
Stephen Hines9ae18b22014-06-10 23:53:00 -0700430 IOFile64Iter++;
431 IOFile32Iter++;
Zonr Changcf6af6a2010-10-12 12:38:51 +0800432 }
433
434 return true;
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800435}
436
Zonr Chang641558f2010-10-12 21:07:06 +0800437void SlangRS::reset() {
438 delete mRSContext;
439 mRSContext = NULL;
Stephen Hines4cc67fc2011-01-31 16:48:57 -0800440 mGeneratedFileNames.clear();
Zonr Chang641558f2010-10-12 21:07:06 +0800441 Slang::reset();
Zonr Chang641558f2010-10-12 21:07:06 +0800442}
443
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800444SlangRS::~SlangRS() {
445 delete mRSContext;
Zonr Chang641558f2010-10-12 21:07:06 +0800446 for (ReflectedDefinitionListTy::iterator I = ReflectedDefinitions.begin(),
447 E = ReflectedDefinitions.end();
448 I != E;
449 I++) {
450 delete I->getValue().first;
451 }
Zonr Chang3a9ca1f2010-10-06 17:52:56 +0800452}
Stephen Hinese639eb52010-11-08 19:27:20 -0800453
454} // namespace slang