private void addResources() throws Abort {
HashSet<String> written = new HashSet<String>();
try {
for (JavaFileObject fo : resourceFileObjects) {
CeyloncFileManager dfm = (CeyloncFileManager) fileManager;
String jarFileName =
JarUtils.toPlatformIndependentPath(
dfm.getLocation(CeylonLocation.RESOURCE_PATH), fo.getName());
if (!written.contains(jarFileName)) {
dfm.setModule(modelLoader.findModuleForFile(new File(jarFileName)));
FileObject outFile =
dfm.getFileForOutput(StandardLocation.CLASS_OUTPUT, "", jarFileName, null);
OutputStream out = outFile.openOutputStream();
try {
InputStream in = new FileInputStream(new File(fo.getName()));
try {
JarUtils.copy(in, out);
} finally {
in.close();
}
} finally {
out.close();
}
written.add(jarFileName);
}
}
} catch (IOException ex) {
throw new Abort(ex);
}
}
@Override
public List<JCCompilationUnit> parseFiles(Iterable<JavaFileObject> fileObjects) {
timer.startTask("parse");
/*
* Stef: see javadoc for fixDefaultPackage() for why this is here.
*/
modelLoader.fixDefaultPackage();
List<JCCompilationUnit> trees = super.parseFiles(fileObjects);
timer.startTask("loadCompiledModules");
LinkedList<JCCompilationUnit> moduleTrees = new LinkedList<JCCompilationUnit>();
// now load modules and associate their moduleless packages with the corresponding modules
trees = loadCompiledModules(trees, moduleTrees);
/*
* Stef: see javadoc for cacheModulelessPackages() for why this is here.
*/
modelLoader.cacheModulelessPackages();
timer.endTask();
return trees;
}
protected void setupIfJDKModule(LazyModule module) {
// Make sure that the java modules are set up properly.
// Bad jdk versions will not be made available and the module validator
// will fail to load their artifacts, and the error is properly handled by the lazy module
// manager in
// attachErrorToDependencyDeclaration()
String nameAsString = module.getNameAsString();
String version = module.getVersion();
if (version != null && AbstractModelLoader.isJDKModule(nameAsString)) {
if (JDKUtils.jdk.providesVersion(version)) {
module.setAvailable(true);
module.setJava(true);
module.setNativeBackend(Backend.Java.nativeAnnotation);
}
}
}
@Override
public void initRound(JavaCompiler prev) {
super.initRound(prev);
// round compilers don't add module trees, it's already done by the first one
addModuleTrees = false;
PhasedUnits oldPUs = ((LanguageCompiler) prev).phasedUnits;
ModuleManager moduleManager = phasedUnits.getModuleManager();
ModuleSourceMapper moduleSourceMapper = phasedUnits.getModuleSourceMapper();
for (PhasedUnit pu : oldPUs.getPhasedUnits()) {
if (pu instanceof CeylonPhasedUnit) {
CeylonPhasedUnit cpu = (CeylonPhasedUnit) pu;
// FIXME: this is bad in many ways
String pkgName;
try {
pkgName = getPackage(((CeylonPhasedUnit) pu).getFileObject());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
continue;
}
// make a Package with no module yet, we will resolve them later
/*
* Stef: see javadoc for findOrCreateModulelessPackage() for why this is here.
*/
com.redhat.ceylon.model.typechecker.model.Package p =
modelLoader.findOrCreateModulelessPackage(pkgName == null ? "" : pkgName);
CeylonPhasedUnit newPu =
new CeylonPhasedUnit(
pu.getUnitFile(),
pu.getSrcDir(),
pu.getCompilationUnit(),
p,
moduleManager,
moduleSourceMapper,
ceylonContext,
cpu.getFileObject(),
cpu.getLineMap());
phasedUnits.addPhasedUnit(pu.getUnitFile(), newPu);
} else {
phasedUnits.addPhasedUnit(pu.getUnitFile(), pu);
}
}
}
private JavaFileObject genCodeUnlessError(Env<AttrContext> env, JCClassDecl cdef)
throws IOException {
CeylonFileObject sourcefile = (CeylonFileObject) env.toplevel.sourcefile;
try {
// do not look at the global number of errors but only those for this file
if (super.gen.genClass(env, cdef)) {
String packageName = cdef.sym.packge().getQualifiedName().toString();
Package pkg = modelLoader.findPackage(packageName);
if (pkg == null) throw new RuntimeException("Failed to find package: " + packageName);
Module module = pkg.getModule();
if (!module.isDefaultModule()) {
String moduleName = module.getNameAsString();
CeylonFileObject moduleFileObject = moduleNamesToFileObjects.get(moduleName);
// if there's no module source file object it means the module descriptor had parse errors
if (moduleFileObject == null || moduleFileObject.hasError()) {
// we do not produce any class files for modules with errors
if (options.get(Option.VERBOSE) != null) {
log.printRawLines(
WriterKind.NOTICE,
"[Not writing class "
+ cdef.sym.className()
+ " because its module has errors: "
+ moduleName
+ "]");
}
return null;
}
}
return writer.writeClass(cdef.sym);
}
} catch (ClassWriter.PoolOverflow ex) {
log.error(cdef.pos(), "limit.pool");
} catch (ClassWriter.StringOverflow ex) {
log.error(cdef.pos(), "limit.string.overflow", ex.value.substring(0, 20));
} catch (CompletionFailure ex) {
chk.completionError(cdef.pos(), ex);
} catch (AssertionError e) {
throw new RuntimeException("Error generating bytecode for " + sourcefile.getName(), e);
}
return null;
}
private List<JCCompilationUnit> loadCompiledModules(
List<JCCompilationUnit> trees, LinkedList<JCCompilationUnit> moduleTrees) {
compilerDelegate.visitModules(phasedUnits);
Modules modules = ceylonContext.getModules();
// now make sure the phase units have their modules and packages set correctly
for (PhasedUnit pu : phasedUnits.getPhasedUnits()) {
Package pkg = pu.getPackage();
loadModuleFromSource(pkg, modules, moduleTrees, trees);
}
// also make sure we have packages and modules set up for every Java file we compile
for (JCCompilationUnit cu : trees) {
// skip Ceylon CUs
if (cu instanceof CeylonCompilationUnit) continue;
String packageName = "";
if (cu.pid != null) packageName = TreeInfo.fullName(cu.pid).toString();
/*
* Stef: see javadoc for findOrCreateModulelessPackage() for why this is here.
*/
Package pkg = modelLoader.findOrCreateModulelessPackage(packageName);
loadModuleFromSource(pkg, modules, moduleTrees, trees);
}
for (PhasedUnit phasedUnit : phasedUnits.getPhasedUnits()) {
for (Tree.ModuleDescriptor modDescr :
phasedUnit.getCompilationUnit().getModuleDescriptors()) {
String name = phasedUnit.getPackage().getNameAsString();
CeylonPhasedUnit cpu = (CeylonPhasedUnit) phasedUnit;
CeylonFileObject cfo = (CeylonFileObject) cpu.getFileObject();
moduleNamesToFileObjects.put(name, cfo);
}
}
if (addModuleTrees) {
for (JCCompilationUnit moduleTree : moduleTrees) {
trees = trees.append(moduleTree);
}
}
return trees;
}
private JCCompilationUnit ceylonParse(JavaFileObject filename, CharSequence readSource) {
if (ceylonEnter.hasRun())
throw new RunTwiceException(
"Trying to load new source file after CeylonEnter has been called: " + filename);
try {
ModuleManager moduleManager = phasedUnits.getModuleManager();
ModuleSourceMapper moduleSourceMapper = phasedUnits.getModuleSourceMapper();
File sourceFile = new File(filename.getName());
// FIXME: temporary solution
VirtualFile file = vfs.getFromFile(sourceFile);
VirtualFile srcDir = vfs.getFromFile(getSrcDir(sourceFile));
String source = readSource.toString();
char[] chars = source.toCharArray();
LineMap map = Position.makeLineMap(chars, chars.length, false);
PhasedUnit phasedUnit = null;
PhasedUnit externalPhasedUnit = compilerDelegate.getExternalSourcePhasedUnit(srcDir, file);
String suppressWarnings = options.get(Option.CEYLONSUPPRESSWARNINGS);
final EnumSet<Warning> suppressedWarnings;
if (suppressWarnings != null) {
if (suppressWarnings.trim().isEmpty()) {
suppressedWarnings = EnumSet.allOf(Warning.class);
} else {
suppressedWarnings = EnumSet.noneOf(Warning.class);
for (String name : suppressWarnings.trim().split(" *, *")) {
suppressedWarnings.add(Warning.valueOf(name));
}
}
} else {
suppressedWarnings = EnumSet.noneOf(Warning.class);
}
if (externalPhasedUnit != null) {
phasedUnit = new CeylonPhasedUnit(externalPhasedUnit, filename, map);
phasedUnit.setSuppressedWarnings(suppressedWarnings);
phasedUnits.addPhasedUnit(externalPhasedUnit.getUnitFile(), phasedUnit);
gen.setMap(map);
String pkgName = phasedUnit.getPackage().getQualifiedNameString();
if ("".equals(pkgName)) {
pkgName = null;
}
return gen.makeJCCompilationUnitPlaceholder(
phasedUnit.getCompilationUnit(), filename, pkgName, phasedUnit);
}
if (phasedUnit == null) {
ANTLRStringStream input = new NewlineFixingStringStream(source);
CeylonLexer lexer = new CeylonLexer(input);
CommonTokenStream tokens = new CommonTokenStream(lexer);
CeylonParser parser = new CeylonParser(tokens);
CompilationUnit cu = parser.compilationUnit();
java.util.List<LexError> lexerErrors = lexer.getErrors();
for (LexError le : lexerErrors) {
printError(le, le.getMessage(), "ceylon.lexer", map);
}
java.util.List<ParseError> parserErrors = parser.getErrors();
for (ParseError pe : parserErrors) {
printError(pe, pe.getMessage(), "ceylon.parser", map);
}
// if we continue and it's not a descriptor, we don't care about errors
if ((options.get(Option.CEYLONCONTINUE) != null
&& !ModuleManager.MODULE_FILE.equals(sourceFile.getName())
&& !ModuleManager.PACKAGE_FILE.equals(sourceFile.getName()))
// otherwise we care about errors
|| (lexerErrors.size() == 0 && parserErrors.size() == 0)) {
// FIXME: this is bad in many ways
String pkgName = getPackage(filename);
// make a Package with no module yet, we will resolve them later
/*
* Stef: see javadoc for findOrCreateModulelessPackage() for why this is here.
*/
com.redhat.ceylon.model.typechecker.model.Package p =
modelLoader.findOrCreateModulelessPackage(pkgName == null ? "" : pkgName);
phasedUnit =
new CeylonPhasedUnit(
file,
srcDir,
cu,
p,
moduleManager,
moduleSourceMapper,
ceylonContext,
filename,
map);
phasedUnit.setSuppressedWarnings(suppressedWarnings);
phasedUnits.addPhasedUnit(file, phasedUnit);
gen.setMap(map);
return gen.makeJCCompilationUnitPlaceholder(cu, filename, pkgName, phasedUnit);
}
}
} catch (RuntimeException e) {
throw e;
} catch (Exception e) {
throw new RuntimeException(e);
}
JCCompilationUnit result =
make.TopLevel(List.<JCAnnotation>nil(), null, List.<JCTree>of(make.Erroneous()));
result.sourcefile = filename;
return result;
}
