From e8c80f152fd2c0058689dff49cf013c9bf7eb2c1 Mon Sep 17 00:00:00 2001 From: Hubert Plociniczak Date: Tue, 13 Apr 2010 08:12:05 +0000 Subject: Some clean-ups. --- .../scala/tools/nsc/dependencies/Files.scala | 176 +++++++++++---------- 1 file changed, 92 insertions(+), 84 deletions(-) (limited to 'src/compiler') diff --git a/src/compiler/scala/tools/nsc/dependencies/Files.scala b/src/compiler/scala/tools/nsc/dependencies/Files.scala index 09f694b6ca..194351a13f 100644 --- a/src/compiler/scala/tools/nsc/dependencies/Files.scala +++ b/src/compiler/scala/tools/nsc/dependencies/Files.scala @@ -1,47 +1,48 @@ package scala.tools.nsc -package dependencies; +package dependencies import java.io.{InputStream, OutputStream, PrintStream, InputStreamReader, BufferedReader} -import io.{AbstractFile, PlainFile} +import io.{AbstractFile, PlainFile, VirtualFile} -import scala.collection._;import scala.tools.nsc.io.VirtualFile +import scala.collection._ trait Files { self : SubComponent => - class FileDependencies(val classpath : String) { + class FileDependencies(val classpath: String) { import FileDependencies._ - class Tracker extends mutable.OpenHashMap[AbstractFile, mutable.Set[AbstractFile]]{ + class Tracker extends mutable.OpenHashMap[AbstractFile, mutable.Set[AbstractFile]] { override def default(key: AbstractFile) = { - this(key) = new mutable.HashSet[AbstractFile]; - this(key); + this(key) = new mutable.HashSet[AbstractFile] + this(key) } } val dependencies = new Tracker - val targets = new Tracker; + val targets = new Tracker def isEmpty = dependencies.isEmpty && targets.isEmpty def emits(source: AbstractFile, result: AbstractFile) = - targets(source) += result; + targets(source) += result def depends(from: AbstractFile, on: AbstractFile) = - dependencies(from) += on; + dependencies(from) += on - def reset(file: AbstractFile) = dependencies -= file; + def reset(file: AbstractFile) = dependencies -= file - def cleanEmpty() = { - dependencies foreach {case (key, value) => value.retain(x => x.exists && (x ne RemovedFile))} - dependencies.retain((key, value) => key.exists && !value.isEmpty) - targets foreach {case (key, value) => value.retain(_.exists)} - targets.retain((key, value) => key.exists && !value.isEmpty) + def cleanEmpty = { + dependencies foreach {case (_, value) => + value retain (x => x.exists && (x ne removedFile))} + dependencies retain ((key, value) => key.exists && !value.isEmpty) + targets foreach {case (_, value) => value retain (_.exists)} + targets retain ((key, value) => key.exists && !value.isEmpty) } def containsFile(f: AbstractFile) = targets.contains(f.absolute) - def invalidatedFiles(maxDepth : Int) = { - val direct = new mutable.HashSet[AbstractFile]; + def invalidatedFiles(maxDepth: Int) = { + val direct = new mutable.HashSet[AbstractFile] for ((file, products) <- targets) { // This looks a bit odd. It may seem like one should invalidate a file @@ -53,34 +54,33 @@ trait Files { self : SubComponent => val indirect = dependentFiles(maxDepth, direct) - for ((source, targets) <- targets; - if direct(source) || indirect(source) || (source eq RemovedFile)){ - targets.foreach(_.delete); - targets -= source; + for ((source, targets) <- targets + if direct(source) || indirect(source) || (source eq removedFile)) { + targets foreach (_.delete) + targets -= source } - (direct, indirect); + (direct, indirect) } /** Return the set of files that depend on the given changed files. * It computes the transitive closure up to the given depth. */ def dependentFiles(depth: Int, changed: Set[AbstractFile]): Set[AbstractFile] = { - val indirect = new mutable.HashSet[AbstractFile]; - val newInvalidations = new mutable.HashSet[AbstractFile]; + val indirect = new mutable.HashSet[AbstractFile] + val newInvalidations = new mutable.HashSet[AbstractFile] - def invalid(file: AbstractFile) = indirect(file) || changed(file) || (file eq RemovedFile) + def invalid(file: AbstractFile) = + indirect(file) || changed(file) || (file eq removedFile) - def go(i : Int) : Unit = if(i > 0){ - newInvalidations.clear; - for((target, depends) <- dependencies; - if !invalid(target); - d <- depends){ + def go(i: Int) : Unit = if(i > 0) { + newInvalidations.clear + for((target, depends) <- dependencies if !invalid(target); + d <- depends) newInvalidations(target) ||= invalid(d) - } - indirect ++= newInvalidations; - if(!newInvalidations.isEmpty) go(i - 1); - else () + + indirect ++= newInvalidations + if (!newInvalidations.isEmpty) go(i - 1) } go(depth) @@ -88,65 +88,73 @@ trait Files { self : SubComponent => indirect --= changed } - def writeTo(file: AbstractFile, fromFile : AbstractFile => String) { + def writeTo(file: AbstractFile, fromFile: AbstractFile => String): Unit = writeToFile(file)(out => writeTo(new PrintStream(out), fromFile)) - } - - def writeTo(print : PrintStream, fromFile : AbstractFile => String) : Unit = { - cleanEmpty(); - def emit(tracker : Tracker){ - for ((f, ds) <- tracker; - d <- ds){ - print.println(fromFile(f) + " -> " + fromFile(d)); - } - } - print.println(classpath); - print.println(FileDependencies.Separator) - emit(dependencies); - print.println(FileDependencies.Separator) - emit(targets); + def writeTo(print: PrintStream, fromFile: AbstractFile => String): Unit = { + def emit(tracker: Tracker) = + for ((f, ds) <- tracker; d <- ds) print.println(fromFile(f) + arrow + fromFile(d)) + cleanEmpty + print.println(classpath) + print.println(separator) + emit(dependencies) + print.println(separator) + emit(targets) } } - object FileDependencies{ - val Separator = "-------"; - private val RemovedFile = new VirtualFile("removed") - - def readFrom(file: AbstractFile, toFile : String => AbstractFile): Option[FileDependencies] = readFromFile(file) { in => - val reader = new BufferedReader(new InputStreamReader(in)) - val it = new FileDependencies(reader.readLine) - reader.readLine - var line : String = null - while ({line = reader.readLine; (line != null) && (line != Separator)}){ - line.split(" -> ") match { - case Array(from, on) => - (toFile(from), toFile(on)) match { - case (null, _) => // fromFile is removed, it's ok - case (fromFile, null) => it.depends(fromFile, RemovedFile) // onFile is removed, should recompile fromFile - case (fromFile, onFile) => it.depends(fromFile, onFile) + object FileDependencies { + private val separator:String = "-------" + private val arrow = " -> " + private val removedFile = new VirtualFile("removed") + + private def validLine(l: String) = (l != null) && (l != separator) + + def readFrom(file: AbstractFile, toFile: String => AbstractFile): Option[FileDependencies] = + readFromFile(file) { in => + val reader = new BufferedReader(new InputStreamReader(in)) + val it = new FileDependencies(reader.readLine) + + def readLines(valid: Boolean)(f: (AbstractFile, AbstractFile) => Unit): Boolean = { + var continue = valid + var line: String = null + while (continue && {line = reader.readLine; validLine(line)}) { + line.split(arrow) match { + case Array(from, on) => f(toFile(from), toFile(on)) + case _ => + global.inform("Parse error: Unrecognised string " + line) + continue = false } - case x => global.inform("Parse error: Unrecognised string " + line); return None + } + continue } - } - while ({line = reader.readLine; (line != null) && (line != Separator)}){ - line.split(" -> ") match { - case Array(source, target) => - val targetFile = toFile(target) - (toFile(source), toFile(target)) match { - case (null, null) => // source and target are all removed, it's ok - case (null, targetFile) => it.emits(RemovedFile, targetFile) // source is removed, should remove relative target later - case (_, null) => // it may has been cleaned outside, or removed during last phase - case (sourceFile, targetFile) => it.emits(sourceFile, targetFile) - } - case x => global.inform("Parse error: Unrecognised string " + line); return None - } + reader.readLine + + val dResult = readLines(true)( + (_, _) match { + case (null, _) => // fromFile is removed, it's ok + case (fromFile, null) => + // onFile is removed, should recompile fromFile + it.depends(fromFile, removedFile) + case (fromFile, onFile) => it.depends(fromFile, onFile) + }) + + readLines(dResult)( + (_, _) match { + case (null, null) => + // source and target are all removed, it's ok + case (null, targetFile) => + // source is removed, should remove relative target later + it.emits(removedFile, targetFile) + case (_, null) => + // it may has been cleaned outside, or removed during last phase + case (sourceFile, targetFile) => it.emits(sourceFile, targetFile) + }) + + Some(it) } - - Some(it) - } } def writeToFile[T](file: AbstractFile)(f: OutputStream => T) : T = { -- cgit v1.2.3