private void run(String[] programArgs, String expectedOutput, String expectedError)
throws IOException, ConfigurationException, InterruptedException {
// Should be initialized at this point by call to Main.run()
Configuration config = Configuration.getConfiguration();
Path fullExecutable = config.getSystemImport().resolve(executable);
List<String> programCommand = new ArrayList<String>();
programCommand.add(fullExecutable.toAbsolutePath().toString());
for (String arg : programArgs) programCommand.add(arg);
Process program = new ProcessBuilder(programCommand).start();
// regular output
BufferedReader reader = new BufferedReader(new InputStreamReader(program.getInputStream()));
BufferedReader errorReader =
new BufferedReader(new InputStreamReader(program.getErrorStream()));
StringBuilder builder = new StringBuilder();
String line;
do {
line = reader.readLine();
if (line != null) builder.append(line).append('\n');
} while (line != null);
String output = builder.toString();
assertEquals(expectedOutput, output);
// error output
builder = new StringBuilder();
do {
line = errorReader.readLine();
if (line != null) builder.append(line).append('\n');
} while (line != null);
String error = builder.toString();
assertEquals(expectedError, error);
program.waitFor(); // keeps program from being deleted while running
}
/**
* Creates a new <code>TypeCollector</code> with the given tree of packages.
*
* @param p package tree
* @param useSourceFiles if true, always use <tt>.shadow</tt> instead of <tt>.meta</tt> files
* @throws ConfigurationException
*/
public TypeCollector(Package p, boolean useSourceFiles) throws ConfigurationException {
super(p);
this.useSourceFiles = useSourceFiles;
config = Configuration.getConfiguration();
}
/*
* Adds a type or a whole package to the current list of imports.
*/
public boolean addImport(String name) {
String separator = File.separator; // Adds some platform independence.
if (separator.equals("\\")) // Hack for Windows to deal with backslash escaping.
separator = "\\\\";
String path = name.replaceAll(":", separator);
/* Which import paths are used depends on whether the requested package
* is in the standard library or not. */
List<Path> importPaths;
if (path.startsWith("shadow")) {
importPaths = new ArrayList<Path>();
importPaths.add(config.getSystemImport());
} else importPaths = config.getImports();
boolean success = false;
if (importPaths != null && importPaths.size() > 0) {
for (Path importPath : importPaths) {
// If an import path is relative, resolving it against the
// current source file will make it absolute.
// If it's absolute, no change will happen.
importPath = currentFile.toPath().getParent().resolve(importPath);
/* No @, must be a whole package import.
* Add everything in the directory. */
if (!path.contains("@")) {
File fullPath = new File(importPath.toFile(), path);
if (fullPath.isDirectory()) {
File[] matchingShadow =
fullPath.listFiles(
new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".shadow");
}
});
File[] matchingMeta =
fullPath.listFiles(
new FilenameFilter() {
@Override
public boolean accept(File dir, String name) {
return name.endsWith(".meta");
}
});
try {
for (File file : matchingShadow)
importList.add(stripExtension(file.getCanonicalPath()));
for (File file : matchingMeta) {
String canonicalPath = stripExtension(file.getCanonicalPath());
if (!importList.contains(canonicalPath)) importList.add(canonicalPath);
}
success = true;
} catch (IOException e) {
}
}
}
/* Single file import. */
else {
File shadowVersion;
File metaVersion;
String fixedPath;
if (path.startsWith("default")) {
fixedPath = path.replaceFirst("default@", "");
shadowVersion = new File(currentFile.getParent(), fixedPath + ".shadow");
metaVersion = new File(currentFile.getParent(), fixedPath + ".meta");
} else {
fixedPath = path.replaceAll("@", separator);
shadowVersion = new File(importPath.toFile(), fixedPath + ".shadow");
metaVersion = new File(importPath.toFile(), fixedPath + ".meta");
}
try {
if (shadowVersion.exists()) {
importList.add(stripExtension(shadowVersion.getCanonicalPath()));
success = true;
} else if (metaVersion.exists()) {
importList.add(stripExtension(metaVersion.getCanonicalPath()));
success = true;
}
} catch (IOException e) {
}
}
if (success) return true;
}
} else addError(Error.INVALID_IMPORT, "No import paths specified, cannot import " + name);
return false;
}
/*
* Does actual collection of types based on a list of files.
*/
private void collectTypes(
List<File> files,
boolean hasMain,
Set<String> mustRecompile,
Map<String, TreeSet<String>> dependencies)
throws ParseException, ShadowException, TypeCheckException, IOException,
ConfigurationException {
// Create and fill the initial set of files to be checked.
TreeSet<String> uncheckedFiles = new TreeSet<String>();
String main = null; // May or may not be null, based on hasMain.
if (files.isEmpty()) {
throw new ConfigurationException("No files provided for typechecking");
} else if (hasMain) {
// Assume the main file is the first and only file.
main = stripExtension(files.get(0).getCanonicalPath());
uncheckedFiles.add(main);
} else {
for (File file : files) {
String path = stripExtension(file.getCanonicalPath());
uncheckedFiles.add(path);
}
}
FilenameFilter filter =
new FilenameFilter() {
public boolean accept(File dir, String name) {
return name.endsWith(".shadow");
}
};
/* Add standard imports. */
File standard =
new File(config.getSystemImport().toFile(), "shadow" + File.separator + "standard");
if (!standard.exists())
throw new ConfigurationException(
"Invalid path to shadow:standard: " + standard.getCanonicalPath());
TreeSet<String> standardDependencies = new TreeSet<String>();
File[] imports = standard.listFiles(filter);
for (File file : imports) {
String name = stripExtension(file.getCanonicalPath());
uncheckedFiles.add(name);
standardDependencies.add(name);
}
/* Add io imports (necessary for console programs). */
File io = new File(config.getSystemImport().toFile(), "shadow" + File.separator + "io");
if (!io.exists())
throw new ConfigurationException("Invalid path to shadow:io: " + io.getCanonicalPath());
imports = standard.listFiles(filter);
for (File file : imports) {
String name = stripExtension(file.getCanonicalPath());
uncheckedFiles.add(name);
standardDependencies.add(name);
}
/* As long as there are unchecked files, remove one and process it. */
while (!uncheckedFiles.isEmpty()) {
String canonical = uncheckedFiles.first();
uncheckedFiles.remove(canonical);
File canonicalFile = new File(canonical + ".shadow");
// Depending on the circumstances, the compiler may choose to either
// compile/recompile source files, or rely on existing binaries/IR.
if (canonicalFile.exists()) {
File meta = new File(canonical + ".meta");
File llvm = new File(canonical + ".ll");
// If source compilation was not requested and the binaries exist
// that are newer than the source, use those binaries.
if (!useSourceFiles
&& !mustRecompile.contains(canonical)
&& meta.exists()
&& meta.lastModified() >= canonicalFile.lastModified()
&& llvm.exists()
&& llvm.lastModified() >= meta.lastModified()) canonicalFile = meta;
else mustRecompile.add(canonical);
} else if (!useSourceFiles) canonicalFile = new File(canonical + ".meta");
ShadowParser parser = new ShadowFileParser(canonicalFile);
currentFile = canonicalFile;
Node node = parser.CompilationUnit();
// Make another collector to walk the current file.
TypeCollector collector = new TypeCollector(new Package(), useSourceFiles);
// Keeping a current files gives us a file whose directory we can check against.
collector.currentFile = currentFile;
ASTWalker walker = new ASTWalker(collector);
walker.walk(node);
if (canonical.equals(main)) mainType = node.getType();
fileTable.put(canonical, node);
/* Copy types from other collector into our package tree. */
for (Type type : collector.packageTree) {
try {
packageTree.addQualifiedPackage(type.getPackage().toString()).addType(type);
if (mainType != null
&& type.getPackage() == packageTree
&& mainType.getPackage() != packageTree) {
// Imported class has default package but the main type doesn't.
// The only classes without a package that will be imported will be
// in the same directory as the main type.
// Implication: classes in the same directory have different packages.
String message =
"Type "
+ type
+ " belongs to the default package, but types defined in the same directory belong to other packages";
addWarning(Error.MISMATCHED_PACKAGE, message);
}
} catch (PackageException e) {
addError(Error.INVALID_PACKAGE, e.getMessage());
}
}
// Copy errors for the other collector into our error list.
if (collector.errorList.size() > 0) errorList.addAll(collector.errorList);
// Copy warnings.
if (collector.warningList.size() > 0) warningList.addAll(collector.warningList);
/* Track the dependencies for this file (if dependencies are being used).
* If any of its dependencies need to be recompiled, this file will need
* to be recompiled.
*/
TreeSet<String> dependencySet = null;
if (dependencies != null) {
dependencySet = new TreeSet<String>(standardDependencies);
dependencies.put(canonical, dependencySet);
}
for (String _import : collector.importList) {
if (!fileTable.containsKey(_import)) uncheckedFiles.add(_import);
if (dependencySet != null) dependencySet.add(_import);
}
/* Add files in the directory after imports. */
File[] directoryFiles = canonicalFile.getParentFile().listFiles(filter);
for (File file : directoryFiles) {
String name = stripExtension(file.getCanonicalPath());
if (!fileTable.containsKey(name)) uncheckedFiles.add(name);
if (dependencySet != null) dependencySet.add(name);
}
/* Copy file table from other collector into our table. */
Map<Type, Node> otherNodeTable = collector.typeTable;
for (Type type : otherNodeTable.keySet()) {
if (!typeTable.containsKey(type)) {
Node otherNode = otherNodeTable.get(type);
typeTable.put(type, otherNode);
}
}
}
}
