diff --git a/src/Pure/Admin/afp.scala b/src/Pure/Admin/afp.scala
--- a/src/Pure/Admin/afp.scala
+++ b/src/Pure/Admin/afp.scala
@@ -1,222 +1,222 @@
/* Title: Pure/Admin/afp.scala
Author: Makarius
Administrative support for the Archive of Formal Proofs.
*/
package isabelle
import java.time.LocalDate
import scala.collection.immutable.SortedMap
object AFP
{
val repos_source = "https://isabelle.sketis.net/repos/afp-devel"
val groups: Map[String, String] =
Map("large" -> "full 64-bit memory model or word arithmetic required",
"slow" -> "CPU time much higher than 60min (on mid-range hardware)",
"very_slow" -> "elapsed time of many hours (on high-end hardware)")
val groups_bulky: List[String] = List("large", "slow")
val chapter: String = "AFP"
val force_partition1: List[String] = List("Category3", "HOL-ODE")
def init(options: Options, base_dir: Path = Path.explode("$AFP_BASE")): AFP =
new AFP(options, base_dir)
/* entries */
def parse_date(s: String): Date =
{
val t = Date.Formatter.pattern("uuuu-MM-dd").parse(s)
Date(LocalDate.from(t).atStartOfDay(Date.timezone_berlin))
}
def trim_mail(s: String): String = s.replaceAll("<[^>]*>", "").trim
sealed case class Entry(name: String, metadata: Properties.T, sessions: List[String])
{
def get(prop: String): Option[String] = Properties.get(metadata, prop)
def get_string(prop: String): String = get(prop).getOrElse("")
def get_strings(prop: String): List[String] =
space_explode(',', get_string(prop)).map(_.trim).filter(_.nonEmpty)
def title: String = get_string("title")
def authors: List[String] = get_strings("author")
def date: Date =
parse_date(get("date").getOrElse(error("Missing date for entry " + quote(name))))
def topics: List[String] = get_strings("topic")
def `abstract`: String = get_string("abstract").trim
def maintainers: List[String] = get_strings("notify")
def contributors: List[String] = get_strings("contributors")
def license: String = get("license").getOrElse("BSD")
def rdf_meta_data: Properties.T =
RDF.meta_data(
proper_string(title).map(Markup.META_TITLE -> _).toList :::
authors.map(Markup.META_CREATOR -> _) :::
contributors.map(Markup.META_CONTRIBUTOR -> _) :::
List(Markup.META_DATE -> RDF.date_format(date)) :::
List(Markup.META_LICENSE -> license) :::
proper_string(`abstract`).map(Markup.META_DESCRIPTION -> _).toList)
}
}
class AFP private(options: Options, val base_dir: Path)
{
override def toString: String = base_dir.expand.toString
val main_dir: Path = base_dir + Path.explode("thys")
/* metadata */
private val entry_metadata: Map[String, Properties.T] =
{
val metadata_file = base_dir + Path.explode("metadata/metadata")
var result = Map.empty[String, Properties.T]
var section = ""
var props = List.empty[Properties.Entry]
val Section = """^\[(\S+)\]\s*$""".r
val Property = """^(\S+)\s*=(.*)$""".r
val Extra_Line = """^\s+(.*)$""".r
val Blank_Line = """^\s*$""".r
- def flush()
+ def flush(): Unit =
{
if (section != "") result += (section -> props.reverse.filter(p => p._2.nonEmpty))
section = ""
props = Nil
}
for ((line, i) <- split_lines(File.read(metadata_file)).zipWithIndex)
{
def err(msg: String): Nothing =
error(msg + Position.here(Position.Line_File(i + 1, metadata_file.expand.implode)))
line match {
case Section(name) => flush(); section = name
case Property(a, b) =>
if (section == "") err("Property without a section")
props = (a -> b.trim) :: props
case Extra_Line(line) =>
props match {
case Nil => err("Extra line without a property")
case (a, b) :: rest => props = (a, b + "\n" + line.trim) :: rest
}
case Blank_Line() =>
case _ => err("Bad input")
}
}
flush()
result
}
/* entries */
val entries_map: SortedMap[String, AFP.Entry] =
{
val entries =
for (name <- Sessions.parse_roots(main_dir + Sessions.ROOTS)) yield {
val metadata =
entry_metadata.getOrElse(name, error("Entry without metadata: " + quote(name)))
val sessions =
Sessions.parse_root_entries(main_dir + Path.explode(name) + Sessions.ROOT).map(_.name)
AFP.Entry(name, metadata, sessions)
}
val entries_map =
(SortedMap.empty[String, AFP.Entry] /: entries)({ case (m, e) => m + (e.name -> e) })
val extra_metadata =
(for ((name, _) <- entry_metadata.iterator if !entries_map.isDefinedAt(name)) yield name).
toList.sorted
if (extra_metadata.nonEmpty)
error("Meta data without entry: " + commas_quote(extra_metadata))
entries_map
}
val entries: List[AFP.Entry] = entries_map.toList.map(_._2)
/* sessions */
val sessions_map: SortedMap[String, AFP.Entry] =
(SortedMap.empty[String, AFP.Entry] /: entries)(
{ case (m1, e) => (m1 /: e.sessions)({ case (m2, s) => m2 + (s -> e) }) })
val sessions: List[String] = entries.flatMap(_.sessions)
val sessions_structure: Sessions.Structure =
Sessions.load_structure(options, dirs = List(main_dir)).
selection(Sessions.Selection(sessions = sessions.toList))
/* dependency graph */
private def sessions_deps(entry: AFP.Entry): List[String] =
entry.sessions.flatMap(sessions_structure.imports_graph.imm_preds).distinct.sorted
lazy val entries_graph: Graph[String, Unit] =
{
val session_entries =
(Map.empty[String, String] /: entries) {
case (m1, e) => (m1 /: e.sessions) { case (m2, s) => m2 + (s -> e.name) }
}
(Graph.empty[String, Unit] /: entries) { case (g, entry) =>
val e1 = entry.name
(g.default_node(e1, ()) /: sessions_deps(entry)) { case (g1, s) =>
(g1 /: session_entries.get(s).filterNot(_ == e1)) { case (g2, e2) =>
try { g2.default_node(e2, ()).add_edge_acyclic(e2, e1) }
catch {
case exn: Graph.Cycles[_] =>
error(cat_lines(exn.cycles.map(cycle =>
"Cyclic dependency of " + cycle.map(c => quote(c.toString)).mkString(" via ") +
" due to session " + quote(s))))
}
}
}
}
}
def entries_graph_display: Graph_Display.Graph =
Graph_Display.make_graph(entries_graph)
def entries_json_text: String =
(for (entry <- entries.iterator) yield {
val distrib_deps = sessions_deps(entry).filterNot(sessions.contains(_))
val afp_deps = entries_graph.imm_preds(entry.name).toList
"""
{""" + JSON.Format(entry.name) + """:
{"distrib_deps": """ + JSON.Format(distrib_deps) + """,
"afp_deps": """ + JSON.Format(afp_deps) + """
}
}"""
}).mkString("[", ", ", "\n]\n")
/* partition sessions */
def partition(n: Int): List[String] =
n match {
case 0 => Nil
case 1 | 2 =>
val graph = sessions_structure.build_graph.restrict(sessions.toSet)
val force_part1 =
graph.all_preds(graph.all_succs(AFP.force_partition1.filter(graph.defined))).toSet
val (part1, part2) = graph.keys.partition(a => force_part1(a) || graph.is_isolated(a))
if (n == 1) part1 else part2
case _ => error("Bad AFP partition: " + n + " (should be 0, 1, 2)")
}
}
diff --git a/src/Pure/Admin/build_csdp.scala b/src/Pure/Admin/build_csdp.scala
--- a/src/Pure/Admin/build_csdp.scala
+++ b/src/Pure/Admin/build_csdp.scala
@@ -1,207 +1,207 @@
/* Title: Pure/Admin/build_csdp.scala
Author: Makarius
Build Isabelle CSDP component from official download.
*/
package isabelle
object Build_CSDP
{
// Note: version 6.2.0 does not quite work for the "sos" proof method
val default_download_url = "https://github.com/coin-or/Csdp/archive/releases/6.1.1.tar.gz"
/* flags */
sealed case class Flags(platform: String, CFLAGS: String = "", LIBS: String = "")
{
val changed: List[(String, String)] =
List("CFLAGS" -> CFLAGS, "LIBS" -> LIBS).filter(p => p._2.nonEmpty)
def print: Option[String] =
if (changed.isEmpty) None
else
Some(" * " + platform + ":\n" + changed.map(p => " " + p._1 + "=" + p._2)
.mkString("\n"))
- def change(path: Path)
+ def change(path: Path): Unit =
{
def change_line(line: String, entry: (String, String)): String =
line.replaceAll(entry._1 + "=.*", entry._1 + "=" + entry._2)
File.change(path, s =>
split_lines(s).map(line => (line /: changed)(change_line)).mkString("\n"))
}
}
val build_flags: List[Flags] =
List(
Flags("arm64-linux",
CFLAGS = "-O3 -ansi -Wall -DNOSHORTS -DBIT64 -DUSESIGTERM -DUSEGETTIME -I../include",
LIBS = "-static -L../lib -lsdp -llapack -lblas -lgfortran -lm"),
Flags("x86_64-linux",
CFLAGS = "-O3 -ansi -Wall -DNOSHORTS -DBIT64 -DUSESIGTERM -DUSEGETTIME -I../include",
LIBS = "-static -L../lib -lsdp -llapack -lblas -lgfortran -lquadmath -lm"),
Flags("x86_64-darwin",
CFLAGS = "-O3 -Wall -DNOSHORTS -DBIT64 -DUSESIGTERM -DUSEGETTIME -I../include",
LIBS = "-L../lib -lsdp -llapack -lblas -lm"),
Flags("x86_64-windows"))
/* build CSDP */
def build_csdp(
download_url: String = default_download_url,
verbose: Boolean = false,
progress: Progress = new Progress,
target_dir: Path = Path.current,
- mingw: MinGW = MinGW.none)
+ mingw: MinGW = MinGW.none): Unit =
{
mingw.check
Isabelle_System.with_tmp_dir("build")(tmp_dir =>
{
/* component */
val Archive_Name = """^.*?([^/]+)$""".r
val Version = """^[^0-9]*([0-9].*)\.tar.gz$""".r
val archive_name =
download_url match {
case Archive_Name(name) => name
case _ => error("Failed to determine source archive name from " + quote(download_url))
}
val version =
archive_name match {
case Version(version) => version
case _ => error("Failed to determine component version from " + quote(archive_name))
}
val component_name = "csdp-" + version
val component_dir = Isabelle_System.new_directory(target_dir + Path.basic(component_name))
progress.echo("Component " + component_dir)
/* platform */
val platform_name =
proper_string(Isabelle_System.getenv("ISABELLE_WINDOWS_PLATFORM64")) orElse
proper_string(Isabelle_System.getenv("ISABELLE_PLATFORM64")) getOrElse
error("No 64bit platform")
val platform_dir = Isabelle_System.make_directory(component_dir + Path.basic(platform_name))
/* download source */
val archive_path = tmp_dir + Path.basic(archive_name)
Isabelle_System.download(download_url, archive_path, progress = progress)
Isabelle_System.bash("tar xzf " + File.bash_path(archive_path), cwd = tmp_dir.file).check
val source_name = File.get_dir(tmp_dir)
Isabelle_System.bash(
"tar xzf " + archive_path + " && mv " + Bash.string(source_name) + " src",
cwd = component_dir.file).check
/* build */
progress.echo("Building CSDP for " + platform_name + " ...")
val build_dir = tmp_dir + Path.basic(source_name)
build_flags.find(flags => flags.platform == platform_name) match {
case None => error("No build flags for platform " + quote(platform_name))
case Some(flags) =>
File.find_files(build_dir.file, pred = file => file.getName == "Makefile").
foreach(file => flags.change(File.path(file)))
}
progress.bash(mingw.bash_script("make"), cwd = build_dir.file, echo = verbose).check
/* install */
Isabelle_System.copy_file(build_dir + Path.explode("LICENSE"), component_dir)
Isabelle_System.copy_file(build_dir + Path.explode("solver/csdp").platform_exe, platform_dir)
if (Platform.is_windows) {
Executable.libraries_closure(platform_dir + Path.explode("csdp.exe"), mingw = mingw,
filter =
Set("libblas", "liblapack", "libgfortran", "libgcc_s_seh",
"libquadmath", "libwinpthread"))
}
/* settings */
val etc_dir = Isabelle_System.make_directory(component_dir + Path.basic("etc"))
File.write(etc_dir + Path.basic("settings"),
"""# -*- shell-script -*- :mode=shellscript:
ISABELLE_CSDP="$COMPONENT/${ISABELLE_WINDOWS_PLATFORM64:-$ISABELLE_PLATFORM64}/csdp"
""")
/* README */
File.write(component_dir + Path.basic("README"),
"""This is CSDP """ + version + """ from
""" + download_url + """
Makefile flags have been changed for various platforms as follows:
""" + build_flags.flatMap(_.print).mkString("\n\n") + """
The distribution has been built like this:
cd src && make
Only the bare "solver/csdp" program is used for Isabelle.
Makarius
""" + Date.Format.date(Date.now()) + "\n")
})
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_csdp", "build prover component from official download", Scala_Project.here,
args =>
{
var target_dir = Path.current
var mingw = MinGW.none
var download_url = default_download_url
var verbose = false
val getopts = Getopts("""
Usage: isabelle build_csdp [OPTIONS]
Options are:
-D DIR target directory (default ".")
-M DIR msys/mingw root specification for Windows
-U URL download URL
(default: """" + default_download_url + """")
-v verbose
Build prover component from official download.
""",
"D:" -> (arg => target_dir = Path.explode(arg)),
"M:" -> (arg => mingw = MinGW(Path.explode(arg))),
"U:" -> (arg => download_url = arg),
"v" -> (_ => verbose = true))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val progress = new Console_Progress()
build_csdp(download_url = download_url, verbose = verbose, progress = progress,
target_dir = target_dir, mingw = mingw)
})
}
diff --git a/src/Pure/Admin/build_cygwin.scala b/src/Pure/Admin/build_cygwin.scala
--- a/src/Pure/Admin/build_cygwin.scala
+++ b/src/Pure/Admin/build_cygwin.scala
@@ -1,89 +1,89 @@
/* Title: Pure/Admin/build_cygwin.scala
Author: Makarius
Produce pre-canned Cygwin distribution for Isabelle.
*/
package isabelle
object Build_Cygwin
{
val default_mirror: String = "https://isabelle.sketis.net/cygwin_2021"
val packages: List[String] =
List("curl", "libgmp-devel", "nano", "perl", "perl-libwww-perl", "rlwrap", "unzip")
def build_cygwin(progress: Progress,
mirror: String = default_mirror,
- more_packages: List[String] = Nil)
+ more_packages: List[String] = Nil): Unit =
{
require(Platform.is_windows, "Windows platform expected")
Isabelle_System.with_tmp_dir("cygwin")(tmp_dir =>
{
val cygwin = tmp_dir + Path.explode("cygwin")
val cygwin_etc = cygwin + Path.explode("etc")
val cygwin_isabelle = Isabelle_System.make_directory(cygwin + Path.explode("isabelle"))
val cygwin_exe_name = mirror + "/setup-x86_64.exe"
val cygwin_exe = cygwin_isabelle + Path.explode("cygwin.exe")
Bytes.write(cygwin_exe,
try { Bytes.read(Url(cygwin_exe_name)) }
catch { case ERROR(_) => error("Failed to download " + quote(cygwin_exe_name)) })
File.write(cygwin_isabelle + Path.explode("cygwin_mirror"), mirror)
File.set_executable(cygwin_exe, true)
Isabelle_System.bash(File.bash_path(cygwin_exe) + " -h /dev/null").check
val res =
progress.bash(
File.bash_path(cygwin_exe) + " --site " + Bash.string(mirror) + " --no-verify" +
" --local-package-dir 'C:\\temp'" +
" --root " + File.bash_platform_path(cygwin) +
" --packages " + quote((packages ::: more_packages).mkString(",")) +
" --no-shortcuts --no-startmenu --no-desktop --quiet-mode",
echo = true)
if (!res.ok || !cygwin_etc.is_dir) error("Failed")
for (name <- List("hosts", "protocols", "services", "networks", "passwd", "group"))
(cygwin_etc + Path.explode(name)).file.delete
(cygwin + Path.explode("Cygwin.bat")).file.delete
val archive = "cygwin-" + Date.Format("uuuuMMdd")(Date.now()) + ".tar.gz"
Isabelle_System.gnutar("-czf " + Bash.string(archive) + " cygwin", dir = tmp_dir).check
})
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_cygwin", "produce pre-canned Cygwin distribution for Isabelle",
Scala_Project.here, args =>
{
var mirror = default_mirror
var more_packages: List[String] = Nil
val getopts =
Getopts("""
Usage: isabelle build_cygwin [OPTIONS]
Options are:
-R MIRROR Cygwin mirror site (default """ + quote(default_mirror) + """)
-p NAME additional Cygwin package
Produce pre-canned Cygwin distribution for Isabelle: this requires
Windows administrator mode.
""",
"R:" -> (arg => mirror = arg),
"p:" -> (arg => more_packages ::= arg))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
build_cygwin(new Console_Progress(), mirror = mirror, more_packages = more_packages)
})
}
diff --git a/src/Pure/Admin/build_doc.scala b/src/Pure/Admin/build_doc.scala
--- a/src/Pure/Admin/build_doc.scala
+++ b/src/Pure/Admin/build_doc.scala
@@ -1,107 +1,107 @@
/* Title: Pure/Admin/build_doc.scala
Author: Makarius
Build Isabelle documentation.
*/
package isabelle
object Build_Doc
{
/* build_doc */
def build_doc(
options: Options,
progress: Progress = new Progress,
all_docs: Boolean = false,
max_jobs: Int = 1,
- docs: List[String] = Nil)
+ docs: List[String] = Nil): Unit =
{
val store = Sessions.store(options)
val sessions_structure = Sessions.load_structure(options)
val selected =
for {
session <- sessions_structure.build_topological_order
info = sessions_structure(session)
if info.groups.contains("doc")
doc = info.options.string("document_variants")
if all_docs || docs.contains(doc)
} yield (doc, session)
val documents = selected.map(_._1)
val selection = Sessions.Selection(sessions = selected.map(_._2))
docs.filter(doc => !documents.contains(doc)) match {
case Nil =>
case bad => error("No documentation session for " + commas_quote(bad))
}
progress.echo("Build started for sessions " + commas_quote(selection.sessions))
Build.build(options, selection = selection, progress = progress, max_jobs = max_jobs).ok ||
error("Build failed")
progress.echo("Build started for documentation " + commas_quote(documents))
val doc_options = options + "document=pdf"
val deps = Sessions.load_structure(doc_options).selection_deps(selection)
val errs =
Par_List.map[(String, String), Option[String]](
{
case (doc, session) =>
try {
progress.echo("Documentation " + quote(doc) + " ...")
using(store.open_database_context())(db_context =>
Presentation.build_documents(session, deps, db_context,
output_pdf = Some(Path.explode("~~/doc"))))
None
}
catch {
case Exn.Interrupt.ERROR(msg) =>
val sep = if (msg.contains('\n')) "\n" else " "
Some("Documentation " + quote(doc) + " failed:" + sep + msg)
}
}, selected).flatten
if (errs.nonEmpty) error(cat_lines(errs))
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_doc", "build Isabelle documentation", Scala_Project.here, args =>
{
var all_docs = false
var max_jobs = 1
var options = Options.init()
val getopts =
Getopts("""
Usage: isabelle build_doc [OPTIONS] [DOCS ...]
Options are:
-a select all documentation sessions
-j INT maximum number of parallel jobs (default 1)
-o OPTION override Isabelle system OPTION (via NAME=VAL or NAME)
Build Isabelle documentation from documentation sessions with
suitable document_variants entry.
""",
"a" -> (_ => all_docs = true),
"j:" -> (arg => max_jobs = Value.Int.parse(arg)),
"o:" -> (arg => options = options + arg))
val docs = getopts(args)
if (!all_docs && docs.isEmpty) getopts.usage()
val progress = new Console_Progress()
progress.interrupt_handler {
build_doc(options, progress, all_docs, max_jobs, docs)
}
})
}
diff --git a/src/Pure/Admin/build_e.scala b/src/Pure/Admin/build_e.scala
--- a/src/Pure/Admin/build_e.scala
+++ b/src/Pure/Admin/build_e.scala
@@ -1,145 +1,145 @@
/* Title: Pure/Admin/build_e.scala
Author: Makarius
Build Isabelle E prover component from official downloads.
*/
package isabelle
object Build_E
{
/* build E prover */
val default_version = "2.5"
val default_download_url = "https://wwwlehre.dhbw-stuttgart.de/~sschulz/WORK/E_DOWNLOAD"
def build_e(
version: String = default_version,
download_url: String = default_download_url,
verbose: Boolean = false,
progress: Progress = new Progress,
- target_dir: Path = Path.current)
+ target_dir: Path = Path.current): Unit =
{
Isabelle_System.with_tmp_dir("build")(tmp_dir =>
{
/* component */
val component_name = "e-" + version
val component_dir = Isabelle_System.new_directory(target_dir + Path.basic(component_name))
progress.echo("Component " + component_dir)
val platform_name =
proper_string(Isabelle_System.getenv("ISABELLE_PLATFORM64"))
.getOrElse(error("No 64bit platform"))
val platform_dir = Isabelle_System.make_directory(component_dir + Path.basic(platform_name))
/* download source */
val archive_url = download_url + "/V_" + version + "/E.tgz"
val archive_path = tmp_dir + Path.explode("E.tgz")
Isabelle_System.download(archive_url, archive_path, progress = progress)
Isabelle_System.bash("tar xzf " + archive_path, cwd = tmp_dir.file).check
Isabelle_System.bash("tar xzf " + archive_path + " && mv E src", cwd = component_dir.file).check
/* build */
progress.echo("Building E prover for " + platform_name + " ...")
val build_dir = tmp_dir + Path.basic("E")
val build_options =
{
val result = Isabelle_System.bash("./configure --help", cwd = build_dir.file)
if (result.check.out.containsSlice("--enable-ho")) " --enable-ho" else ""
}
val build_script = "./configure" + build_options + " && make"
Isabelle_System.bash(build_script,
cwd = build_dir.file,
progress_stdout = progress.echo_if(verbose, _),
progress_stderr = progress.echo_if(verbose, _)).check
/* install */
Isabelle_System.copy_file(build_dir + Path.basic("COPYING"),
component_dir + Path.basic("LICENSE"))
val install_files = List("epclextract", "eprover", "eprover-ho")
for (name <- install_files ::: install_files.map(_ + ".exe")) {
val path = build_dir + Path.basic("PROVER") + Path.basic(name)
if (path.is_file) Isabelle_System.copy_file(path, platform_dir)
}
Isabelle_System.bash("if [ -f eprover-ho ]; then mv eprover-ho eprover; fi",
cwd = platform_dir.file).check
/* settings */
val etc_dir = Isabelle_System.make_directory(component_dir + Path.basic("etc"))
File.write(etc_dir + Path.basic("settings"),
"""# -*- shell-script -*- :mode=shellscript:
E_HOME="$COMPONENT/$ISABELLE_PLATFORM64"
E_VERSION=""" + quote(version) + """
""")
/* README */
File.write(component_dir + Path.basic("README"),
"This is E prover " + version + " from\n" + archive_url + """
The distribution has been built like this:
cd src && """ + build_script + """
Only a few executables from PROVERS/ have been moved to the platform-specific
Isabelle component directory: x86_64-linux etc.
Makarius
""" + Date.Format.date(Date.now()) + "\n")
})
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_e", "build prover component from source distribution", Scala_Project.here,
args =>
{
var target_dir = Path.current
var version = default_version
var download_url = default_download_url
var verbose = false
val getopts = Getopts("""
Usage: isabelle build_e [OPTIONS]
Options are:
-D DIR target directory (default ".")
-U URL download URL
(default: """" + default_download_url + """")
-V VERSION version (default: """ + default_version + """)
-v verbose
Build prover component from the specified source distribution.
""",
"D:" -> (arg => target_dir = Path.explode(arg)),
"U:" -> (arg => download_url = arg),
"V:" -> (arg => version = arg),
"v" -> (_ => verbose = true))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val progress = new Console_Progress()
build_e(version = version, download_url = download_url,
verbose = verbose, progress = progress, target_dir = target_dir)
})
}
diff --git a/src/Pure/Admin/build_fonts.scala b/src/Pure/Admin/build_fonts.scala
--- a/src/Pure/Admin/build_fonts.scala
+++ b/src/Pure/Admin/build_fonts.scala
@@ -1,363 +1,363 @@
/* Title: Pure/Admin/build_fonts.scala
Author: Makarius
Build standard Isabelle fonts: DejaVu base + Isabelle symbols.
*/
package isabelle
object Build_Fonts
{
/* relevant codepoint ranges */
object Range
{
def base_font: Seq[Int] =
(0x0020 to 0x007e) ++ // ASCII
(0x00a0 to 0x024f) ++ // Latin Extended-A/B
(0x0400 to 0x04ff) ++ // Cyrillic
(0x0600 to 0x06ff) ++ // Arabic
Seq(
0x02dd, // hungarumlaut
0x2018, // single quote
0x2019, // single quote
0x201a, // single quote
0x201c, // double quote
0x201d, // double quote
0x201e, // double quote
0x2039, // single guillemet
0x203a, // single guillemet
0x204b, // FOOTNOTE
0x20ac, // Euro
0x2710, // pencil
0xfb01, // ligature fi
0xfb02, // ligature fl
0xfffd, // replacement character
)
def isabelle_font: Seq[Int] =
Seq(
0x05, // X
0x06, // Y
0x07, // EOF
0x7f, // DEL
0xaf, // INVERSE
0xac, // logicalnot
0xb0, // degree
0xb1, // plusminus
0xb7, // periodcentered
0xd7, // multiply
0xf7, // divide
) ++
(0x0370 to 0x03ff) ++ // Greek (pseudo math)
(0x0590 to 0x05ff) ++ // Hebrew (non-mono)
Seq(
0x2010, // hyphen
0x2013, // dash
0x2014, // dash
0x2015, // dash
0x2020, // dagger
0x2021, // double dagger
0x2022, // bullet
0x2026, // ellipsis
0x2030, // perthousand
0x2032, // minute
0x2033, // second
0x2038, // caret
0x20cd, // currency symbol
) ++
(0x2100 to 0x214f) ++ // Letterlike Symbols
(0x2190 to 0x21ff) ++ // Arrows
(0x2200 to 0x22ff) ++ // Mathematical Operators
(0x2300 to 0x23ff) ++ // Miscellaneous Technical
Seq(
0x2423, // graphic for space
0x2500, // box drawing
0x2501, // box drawing
0x2508, // box drawing
0x2509, // box drawing
0x2550, // box drawing
) ++
(0x25a0 to 0x25ff) ++ // Geometric Shapes
Seq(
0x261b, // ACTION
0x2660, // spade suit
0x2661, // heart suit
0x2662, // diamond suit
0x2663, // club suit
0x266d, // musical flat
0x266e, // musical natural
0x266f, // musical sharp
0x2756, // UNDEFINED
0x2759, // BOLD
0x27a7, // DESCR
0x27e6, // left white square bracket
0x27e7, // right white square bracket
0x27e8, // left angle bracket
0x27e9, // right angle bracket
0x27ea, // left double angle bracket
0x27eb, // right double angle bracket
) ++
(0x27f0 to 0x27ff) ++ // Supplemental Arrows-A
(0x2900 to 0x297f) ++ // Supplemental Arrows-B
(0x2980 to 0x29ff) ++ // Miscellaneous Mathematical Symbols-B
(0x2a00 to 0x2aff) ++ // Supplemental Mathematical Operators
Seq(0x2b1a) ++ // VERBATIM
(0x1d400 to 0x1d7ff) ++ // Mathematical Alphanumeric Symbols
Seq(
0x1f310, // globe with meridians (Symbola font)
0x1f4d3, // notebook (Symbola font)
0x1f5c0, // folder (Symbola font)
0x1f5cf, // page (Symbola font)
)
def isabelle_math_font: Seq[Int] =
(0x21 to 0x2f) ++ // bang .. slash
(0x3a to 0x40) ++ // colon .. atsign
(0x5b to 0x5f) ++ // leftbracket .. underscore
(0x7b to 0x7e) ++ // leftbrace .. tilde
Seq(
0xa9, // copyright
0xae, // registered
)
val vacuous_font: Seq[Int] =
Seq(0x3c) // "<" as template
}
/* font families */
sealed case class Family(
plain: String = "",
bold: String = "",
italic: String = "",
bold_italic: String = "")
{
val fonts: List[String] =
proper_string(plain).toList :::
proper_string(bold).toList :::
proper_string(italic).toList :::
proper_string(bold_italic).toList
def get(index: Int): String = fonts(index % fonts.length)
}
object Family
{
def isabelle_symbols: Family =
Family(
plain = "IsabelleSymbols.sfd",
bold = "IsabelleSymbolsBold.sfd")
def deja_vu_sans_mono: Family =
Family(
plain = "DejaVuSansMono.ttf",
bold = "DejaVuSansMono-Bold.ttf",
italic = "DejaVuSansMono-Oblique.ttf",
bold_italic = "DejaVuSansMono-BoldOblique.ttf")
def deja_vu_sans: Family =
Family(
plain = "DejaVuSans.ttf",
bold = "DejaVuSans-Bold.ttf",
italic = "DejaVuSans-Oblique.ttf",
bold_italic = "DejaVuSans-BoldOblique.ttf")
def deja_vu_serif: Family =
Family(
plain = "DejaVuSerif.ttf",
bold = "DejaVuSerif-Bold.ttf",
italic = "DejaVuSerif-Italic.ttf",
bold_italic = "DejaVuSerif-BoldItalic.ttf")
def vacuous: Family = Family(plain = "Vacuous.sfd")
}
/* hinting */
// see https://www.freetype.org/ttfautohint/doc/ttfautohint.html
- private def auto_hint(source: Path, target: Path)
+ private def auto_hint(source: Path, target: Path): Unit =
{
Isabelle_System.bash("ttfautohint -i " +
File.bash_path(source) + " " + File.bash_path(target)).check
}
private def hinted_path(hinted: Boolean): Path =
if (hinted) Path.basic("ttf-hinted") else Path.basic("ttf")
private val hinting = List(false, true)
/* build fonts */
private def find_file(dirs: List[Path], name: String): Path =
{
val path = Path.explode(name)
dirs.collectFirst({ case dir if (dir + path).is_file => dir + path }) match {
case Some(file) => file
case None =>
error(cat_lines(
("Failed to find font file " + path + " in directories:") ::
dirs.map(dir => " " + dir.toString)))
}
}
val default_sources: List[Family] =
List(Family.deja_vu_sans_mono, Family.deja_vu_sans, Family.deja_vu_serif)
val default_target_dir: Path = Path.explode("isabelle_fonts")
def build_fonts(
sources: List[Family] = default_sources,
source_dirs: List[Path] = Nil,
target_prefix: String = "Isabelle",
target_version: String = "",
target_dir: Path = default_target_dir,
- progress: Progress = new Progress)
+ progress: Progress = new Progress): Unit =
{
progress.echo("Directory " + target_dir)
hinting.foreach(hinted => Isabelle_System.make_directory(target_dir + hinted_path(hinted)))
val font_dirs = source_dirs ::: List(Path.explode("~~/Admin/isabelle_fonts"))
for (dir <- font_dirs if !dir.is_dir) error("Bad source directory: " + dir)
// Isabelle fonts
val targets =
for { source <- sources; (source_font, index) <- source.fonts.zipWithIndex }
yield {
val isabelle_file = find_file(font_dirs, Family.isabelle_symbols.get(index))
val source_file = find_file(font_dirs, source_font)
val source_names = Fontforge.font_names(source_file)
val target_names = source_names.update(prefix = target_prefix, version = target_version)
Isabelle_System.with_tmp_file("font", "ttf")(tmp_file =>
{
for (hinted <- hinting) {
val target_file = target_dir + hinted_path(hinted) + target_names.ttf
progress.echo("Font " + target_file.toString + " ...")
if (hinted) auto_hint(source_file, tmp_file)
else Isabelle_System.copy_file(source_file, tmp_file)
Fontforge.execute(
Fontforge.commands(
Fontforge.open(isabelle_file),
Fontforge.select(Range.isabelle_font),
Fontforge.copy,
Fontforge.close,
Fontforge.open(tmp_file),
Fontforge.select(Range.base_font),
Fontforge.select_invert,
Fontforge.clear,
Fontforge.select(Range.isabelle_font),
Fontforge.paste,
target_names.set,
Fontforge.generate(target_file),
Fontforge.close)
).check
}
})
(target_names.ttf, index)
}
// Vacuous font
{
val vacuous_file = find_file(font_dirs, Family.vacuous.get(0))
val target_names = Fontforge.font_names(vacuous_file)
val target_file = target_dir + hinted_path(false) + target_names.ttf
progress.echo("Font " + target_file.toString + " ...")
val domain =
(for ((name, index) <- targets if index == 0)
yield Fontforge.font_domain(target_dir + hinted_path(false) + name))
.flatten.distinct.sorted
Fontforge.execute(
Fontforge.commands(
Fontforge.open(vacuous_file),
Fontforge.select(Range.vacuous_font),
Fontforge.copy) +
domain.map(code =>
Fontforge.commands(
Fontforge.select(Seq(code)),
Fontforge.paste))
.mkString("\n", "\n", "\n") +
Fontforge.commands(
Fontforge.generate(target_file),
Fontforge.close)
).check
}
// etc/settings
val settings_path = Isabelle_System.make_directory(Components.settings(target_dir))
def fonts_settings(hinted: Boolean): String =
"\n isabelle_fonts \\\n" +
(for ((target, _) <- targets) yield
""" "$COMPONENT/""" + hinted_path(hinted).file_name + "/" + target.file_name + "\"")
.mkString(" \\\n")
File.write(settings_path,
"""# -*- shell-script -*- :mode=shellscript:
if grep "isabelle_fonts_hinted.*=.*false" "$ISABELLE_HOME_USER/etc/preferences" >/dev/null 2>/dev/null
then""" + fonts_settings(false) + """
else""" + fonts_settings(true) + """
fi
isabelle_fonts_hidden "$COMPONENT/""" + hinted_path(false).file_name + """/Vacuous.ttf"
""")
// README
Isabelle_System.copy_file(Path.explode("~~/Admin/isabelle_fonts/README"), target_dir)
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_fonts", "construct Isabelle fonts", Scala_Project.here, args =>
{
var source_dirs: List[Path] = Nil
val getopts = Getopts("""
Usage: isabelle build_fonts [OPTIONS]
Options are:
-d DIR additional source directory
Construct Isabelle fonts from DejaVu font families and Isabelle symbols.
""",
"d:" -> (arg => source_dirs = source_dirs ::: List(Path.explode(arg))))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val target_version = Date.Format("uuuuMMdd")(Date.now())
val target_dir = Path.explode("isabelle_fonts-" + target_version)
val progress = new Console_Progress
build_fonts(source_dirs = source_dirs, target_dir = target_dir,
target_version = target_version, progress = progress)
})
}
diff --git a/src/Pure/Admin/build_history.scala b/src/Pure/Admin/build_history.scala
--- a/src/Pure/Admin/build_history.scala
+++ b/src/Pure/Admin/build_history.scala
@@ -1,618 +1,618 @@
/* Title: Pure/Admin/build_history.scala
Author: Makarius
Build other history versions.
*/
package isabelle
object Build_History
{
/* log files */
val engine = "build_history"
val log_prefix = engine + "_"
/* augment settings */
def augment_settings(
other_isabelle: Other_Isabelle,
threads: Int,
arch_64: Boolean,
heap: Int,
max_heap: Option[Int],
more_settings: List[String]): String =
{
val (ml_platform, ml_settings) =
{
val windows_32 = "x86-windows"
val windows_64 = "x86_64-windows"
val windows_64_32 = "x86_64_32-windows"
val platform_32 = other_isabelle.getenv("ISABELLE_PLATFORM32")
val platform_64 = other_isabelle.getenv("ISABELLE_PLATFORM64")
val platform_64_32 = platform_64.replace("x86_64-", "x86_64_32-")
val polyml_home =
try { Path.explode(other_isabelle.getenv("ML_HOME")).dir }
catch { case ERROR(msg) => error("Bad ML_HOME: " + msg) }
def ml_home(platform: String): Path = polyml_home + Path.explode(platform)
def err(platform: String): Nothing =
error("Platform " + platform + " unavailable on this machine")
def check_dir(platform: String): Boolean =
platform != "" && ml_home(platform).is_dir
val ml_platform =
if (Platform.is_windows && arch_64) {
if (check_dir(windows_64)) windows_64 else err(windows_64)
}
else if (Platform.is_windows && !arch_64) {
if (check_dir(windows_64_32)) windows_64_32
else if (check_dir(windows_32)) windows_32
else platform_32 // x86-cygwin
}
else if (arch_64) {
if (check_dir(platform_64)) platform_64 else err(platform_64)
}
else if (check_dir(platform_64_32)) platform_64_32
else platform_32
val ml_options =
"--minheap " + heap + (if (max_heap.isDefined) " --maxheap " + max_heap.get else "") +
" --gcthreads " + threads +
(if (ml_platform.endsWith("-windows")) " --codepage utf8" else "")
(ml_platform,
List(
"ML_HOME=" + File.bash_path(ml_home(ml_platform)),
"ML_PLATFORM=" + quote(ml_platform),
"ML_OPTIONS=" + quote(ml_options)))
}
val thread_settings =
List(
"ISABELLE_JAVA_SYSTEM_OPTIONS=\"$ISABELLE_JAVA_SYSTEM_OPTIONS -Disabelle.threads=" + threads + "\"",
"ISABELLE_BUILD_OPTIONS=\"threads=" + threads + "\"")
val settings =
List(ml_settings, thread_settings) :::
(if (more_settings.isEmpty) Nil else List(more_settings))
File.append(other_isabelle.etc_settings, "\n" + cat_lines(settings.map(terminate_lines(_))))
ml_platform
}
/** build_history **/
private val default_user_home = Path.explode("$USER_HOME")
private val default_rev = "tip"
private val default_multicore = (1, 1)
private val default_heap = 1500
private val default_isabelle_identifier = "build_history"
def build_history(
options: Options,
root: Path,
user_home: Path = default_user_home,
progress: Progress = new Progress,
rev: String = default_rev,
afp_rev: Option[String] = None,
afp_partition: Int = 0,
isabelle_identifier: String = default_isabelle_identifier,
ml_statistics_step: Int = 1,
component_repository: String = Components.default_component_repository,
components_base: Path = Components.default_components_base,
fresh: Boolean = false,
hostname: String = "",
multicore_base: Boolean = false,
multicore_list: List[(Int, Int)] = List(default_multicore),
arch_64: Boolean = false,
heap: Int = default_heap,
max_heap: Option[Int] = None,
init_settings: List[String] = Nil,
more_settings: List[String] = Nil,
more_preferences: List[String] = Nil,
verbose: Boolean = false,
build_tags: List[String] = Nil,
build_args: List[String] = Nil): List[(Process_Result, Path)] =
{
/* sanity checks */
if (File.eq(Path.explode("~~"), root))
error("Repository coincides with ISABELLE_HOME=" + Path.explode("~~").expand)
for ((threads, _) <- multicore_list if threads < 1)
error("Bad threads value < 1: " + threads)
for ((_, processes) <- multicore_list if processes < 1)
error("Bad processes value < 1: " + processes)
if (heap < 100) error("Bad heap value < 100: " + heap)
if (max_heap.isDefined && max_heap.get < heap)
error("Bad max_heap value < heap: " + max_heap.get)
System.getenv("ISABELLE_SETTINGS_PRESENT") match {
case null | "" =>
case _ => error("Cannot run build_history within existing Isabelle settings environment")
}
/* checkout Isabelle + AFP repository */
def checkout(dir: Path, version: String): String =
{
val hg = Mercurial.repository(dir)
hg.update(rev = version, clean = true)
progress.echo_if(verbose, hg.log(version, options = "-l1"))
hg.id(rev = version)
}
val isabelle_version = checkout(root, rev)
val afp_repos = root + Path.explode("AFP")
val afp_version = afp_rev.map(checkout(afp_repos, _))
val (afp_build_args, afp_sessions) =
if (afp_rev.isEmpty) (Nil, Nil)
else {
val (opt, sessions) =
try {
val afp = AFP.init(options, afp_repos)
("-d", afp.partition(afp_partition))
} catch { case ERROR(_) => ("-D", Nil) }
(List(opt, "~~/AFP/thys"), sessions)
}
/* main */
val other_isabelle =
Other_Isabelle(root, isabelle_identifier = isabelle_identifier,
user_home = user_home, progress = progress)
val build_host = proper_string(hostname) getOrElse Isabelle_System.hostname()
val build_history_date = Date.now()
val build_group_id = build_host + ":" + build_history_date.time.ms
var first_build = true
for ((threads, processes) <- multicore_list) yield
{
/* init settings */
val component_settings =
other_isabelle.init_components(
component_repository = component_repository,
components_base = components_base,
catalogs = List("main", "optional"))
other_isabelle.init_settings(component_settings ::: init_settings)
other_isabelle.resolve_components(echo = verbose)
val ml_platform =
augment_settings(other_isabelle, threads, arch_64, heap, max_heap, more_settings)
File.write(other_isabelle.etc_preferences, cat_lines(more_preferences))
val isabelle_output =
other_isabelle.isabelle_home_user + Path.explode("heaps") +
Path.explode(other_isabelle.getenv("ML_IDENTIFIER"))
val isabelle_output_log = isabelle_output + Path.explode("log")
val isabelle_base_log = isabelle_output + Path.explode("../base_log")
if (first_build) {
other_isabelle.resolve_components(echo = verbose)
if (fresh)
Isabelle_System.rm_tree(other_isabelle.isabelle_home + Path.explode("lib/classes"))
other_isabelle.bash(
"env PATH=\"" + File.bash_path(Path.explode("~~/lib/dummy_stty").expand) + ":$PATH\" " +
"bin/isabelle jedit -b", redirect = true, echo = verbose).check
for {
tool <- List("ghc_setup", "ocaml_setup")
if other_isabelle.getenv("ISABELLE_" + Word.uppercase(tool)) == "true" &&
(other_isabelle.isabelle_home + Path.explode("lib/Tools/" + tool)).is_file
} other_isabelle(tool, echo = verbose)
Isabelle_System.rm_tree(isabelle_base_log)
}
Isabelle_System.rm_tree(isabelle_output)
Isabelle_System.make_directory(isabelle_output)
val log_path =
other_isabelle.isabelle_home_user +
Build_Log.log_subdir(build_history_date) +
Build_Log.log_filename(Build_History.engine, build_history_date,
List(build_host, ml_platform, "M" + threads) ::: build_tags)
Isabelle_System.make_directory(log_path.dir)
val build_out = other_isabelle.isabelle_home_user + Path.explode("log/build.out")
val build_out_progress = new File_Progress(build_out)
build_out.file.delete
/* build */
if (multicore_base && !first_build && isabelle_base_log.is_dir)
Isabelle_System.copy_dir(isabelle_base_log, isabelle_output_log)
val build_start = Date.now()
val build_args1 = List("-v", "-j" + processes) ::: afp_build_args ::: build_args
val build_isabelle =
Other_Isabelle(root, isabelle_identifier = isabelle_identifier,
user_home = user_home, progress = build_out_progress)
val build_result =
build_isabelle("build " + Bash.strings(build_args1 ::: afp_sessions),
redirect = true, echo = true, strict = false)
val build_end = Date.now()
val build_info: Build_Log.Build_Info =
Build_Log.Log_File(log_path.file_name, build_result.out_lines).
parse_build_info(ml_statistics = true)
/* output log */
val store = Sessions.store(options + "build_database_server=false")
val meta_info =
Properties.lines_nonempty(Build_Log.Prop.build_tags.name, build_tags) :::
Properties.lines_nonempty(Build_Log.Prop.build_args.name, build_args1) :::
List(
Build_Log.Prop.build_group_id.name -> build_group_id,
Build_Log.Prop.build_id.name -> (build_host + ":" + build_start.time.ms),
Build_Log.Prop.build_engine.name -> Build_History.engine,
Build_Log.Prop.build_host.name -> build_host,
Build_Log.Prop.build_start.name -> Build_Log.print_date(build_start),
Build_Log.Prop.build_end.name -> Build_Log.print_date(build_end),
Build_Log.Prop.isabelle_version.name -> isabelle_version) :::
afp_version.map(Build_Log.Prop.afp_version.name -> _).toList
build_out_progress.echo("Reading session build info ...")
val session_build_info =
build_info.finished_sessions.flatMap(session_name =>
{
val database = isabelle_output + store.database(session_name)
if (database.is_file) {
using(SQLite.open_database(database))(db =>
{
val theory_timings =
try {
store.read_theory_timings(db, session_name).map(ps =>
Protocol.Theory_Timing_Marker((Build_Log.SESSION_NAME, session_name) :: ps))
}
catch { case ERROR(_) => Nil }
val session_sources =
store.read_build(db, session_name).map(_.sources) match {
case Some(sources) if sources.length == SHA1.digest_length =>
List("Sources " + session_name + " " + sources)
case _ => Nil
}
theory_timings ::: session_sources
})
}
else Nil
})
build_out_progress.echo("Reading ML statistics ...")
val ml_statistics =
build_info.finished_sessions.flatMap(session_name =>
{
val database = isabelle_output + store.database(session_name)
val log_gz = isabelle_output + store.log_gz(session_name)
val properties =
if (database.is_file) {
using(SQLite.open_database(database))(db =>
store.read_ml_statistics(db, session_name))
}
else if (log_gz.is_file) {
Build_Log.Log_File(log_gz).parse_session_info(ml_statistics = true).ml_statistics
}
else Nil
val trimmed_properties =
if (ml_statistics_step <= 0) Nil
else if (ml_statistics_step == 1) properties
else {
(for { (ps, i) <- properties.iterator.zipWithIndex if i % ml_statistics_step == 0 }
yield ps).toList
}
trimmed_properties.map(ps => (Build_Log.SESSION_NAME -> session_name) :: ps)
})
build_out_progress.echo("Reading error messages ...")
val session_errors =
build_info.failed_sessions.flatMap(session_name =>
{
val database = isabelle_output + store.database(session_name)
val errors =
if (database.is_file) {
try {
using(SQLite.open_database(database))(db => store.read_errors(db, session_name))
} // column "errors" could be missing
catch { case _: java.sql.SQLException => Nil }
}
else Nil
errors.map(msg => List(Build_Log.SESSION_NAME -> session_name, Markup.CONTENT -> msg))
})
build_out_progress.echo("Reading heap sizes ...")
val heap_sizes =
build_info.finished_sessions.flatMap(session_name =>
{
val heap = isabelle_output + Path.explode(session_name)
if (heap.is_file)
Some("Heap " + session_name + " (" + Value.Long(heap.file.length) + " bytes)")
else None
})
build_out_progress.echo("Writing log file " + log_path.xz + " ...")
File.write_xz(log_path.xz,
terminate_lines(
Protocol.Meta_Info_Marker(meta_info) :: build_result.out_lines :::
session_build_info :::
ml_statistics.map(Protocol.ML_Statistics_Marker.apply) :::
session_errors.map(Protocol.Error_Message_Marker.apply) :::
heap_sizes), XZ.options(6))
/* next build */
if (multicore_base && first_build && isabelle_output_log.is_dir)
Isabelle_System.copy_dir(isabelle_output_log, isabelle_base_log)
Isabelle_System.rm_tree(isabelle_output)
first_build = false
(build_result, log_path.xz)
}
}
/* command line entry point */
private object Multicore
{
private val Pat1 = """^(\d+)$""".r
private val Pat2 = """^(\d+)x(\d+)$""".r
def parse(s: String): (Int, Int) =
s match {
case Pat1(Value.Int(x)) => (x, 1)
case Pat2(Value.Int(x), Value.Int(y)) => (x, y)
case _ => error("Bad multicore configuration: " + quote(s))
}
}
- def main(args: Array[String])
+ def main(args: Array[String]): Unit =
{
Command_Line.tool {
var afp_rev: Option[String] = None
var multicore_base = false
var components_base: Path = Components.default_components_base
var heap: Option[Int] = None
var max_heap: Option[Int] = None
var multicore_list = List(default_multicore)
var isabelle_identifier = default_isabelle_identifier
var afp_partition = 0
var component_repository = Components.default_component_repository
var more_settings: List[String] = Nil
var more_preferences: List[String] = Nil
var fresh = false
var hostname = ""
var init_settings: List[String] = Nil
var arch_64 = false
var output_file = ""
var rev = default_rev
var ml_statistics_step = 1
var build_tags = List.empty[String]
var user_home = default_user_home
var verbose = false
var exit_code = false
val getopts = Getopts("""
Usage: Admin/build_history [OPTIONS] REPOSITORY [ARGS ...]
Options are:
-A REV include $ISABELLE_HOME/AFP repository at given revision
-B first multicore build serves as base for scheduling information
-C DIR base directory for Isabelle components (default: """ +
Components.default_components_base + """)
-H SIZE minimal ML heap in MB (default: """ + default_heap + """ for x86, """ +
default_heap * 2 + """ for x86_64)
-M MULTICORE multicore configurations (see below)
-N NAME alternative ISABELLE_IDENTIFIER (default: """ + default_isabelle_identifier + """)
-P NUMBER AFP partition number (0, 1, 2, default: 0=unrestricted)
-R URL remote repository for Isabelle components (default: """ +
Components.default_component_repository + """)
-U SIZE maximal ML heap in MB (default: unbounded)
-e TEXT additional text for generated etc/settings
-f fresh build of Isabelle/Scala components (recommended)
-h NAME override local hostname
-i TEXT initial text for generated etc/settings
-m ARCH processor architecture (32=x86, 64=x86_64, default: x86)
-o FILE output file for log names (default: stdout)
-p TEXT additional text for generated etc/preferences
-r REV update to revision (default: """ + default_rev + """)
-s NUMBER step size for ML statistics (0=none, 1=all, n=step, default: 1)
-t TAG free-form build tag (multiple occurrences possible)
-u DIR alternative USER_HOME directory
-v verbose
-x return overall exit code from build processes
Build Isabelle sessions from the history of another REPOSITORY clone,
passing ARGS directly to its isabelle build tool.
Each MULTICORE configuration consists of one or two numbers (default 1):
THREADS or THREADSxPROCESSES, e.g. -M 1,2,4 or -M 1x4,2x2,4.
""",
"A:" -> (arg => afp_rev = Some(arg)),
"B" -> (_ => multicore_base = true),
"C:" -> (arg => components_base = Path.explode(arg)),
"H:" -> (arg => heap = Some(Value.Int.parse(arg))),
"M:" -> (arg => multicore_list = space_explode(',', arg).map(Multicore.parse)),
"N:" -> (arg => isabelle_identifier = arg),
"P:" -> (arg => afp_partition = Value.Int.parse(arg)),
"R:" -> (arg => component_repository = arg),
"U:" -> (arg => max_heap = Some(Value.Int.parse(arg))),
"e:" -> (arg => more_settings = more_settings ::: List(arg)),
"f" -> (_ => fresh = true),
"h:" -> (arg => hostname = arg),
"i:" -> (arg => init_settings = init_settings ::: List(arg)),
"m:" ->
{
case "32" | "x86" => arch_64 = false
case "64" | "x86_64" => arch_64 = true
case bad => error("Bad processor architecture: " + quote(bad))
},
"o:" -> (arg => output_file = arg),
"p:" -> (arg => more_preferences = more_preferences ::: List(arg)),
"r:" -> (arg => rev = arg),
"s:" -> (arg => ml_statistics_step = Value.Int.parse(arg)),
"t:" -> (arg => build_tags = build_tags ::: List(arg)),
"u:" -> (arg => user_home = Path.explode(arg)),
"v" -> (_ => verbose = true),
"x" -> (_ => exit_code = true))
val more_args = getopts(args)
val (root, build_args) =
more_args match {
case root :: build_args => (Path.explode(root), build_args)
case _ => getopts.usage()
}
val progress = new Console_Progress(stderr = true)
val results =
build_history(Options.init(), root, user_home = user_home, progress = progress, rev = rev,
afp_rev = afp_rev, afp_partition = afp_partition,
isabelle_identifier = isabelle_identifier, ml_statistics_step = ml_statistics_step,
component_repository = component_repository, components_base = components_base,
fresh = fresh, hostname = hostname, multicore_base = multicore_base,
multicore_list = multicore_list, arch_64 = arch_64,
heap = heap.getOrElse(if (arch_64) default_heap * 2 else default_heap),
max_heap = max_heap, init_settings = init_settings, more_settings = more_settings,
more_preferences = more_preferences, verbose = verbose, build_tags = build_tags,
build_args = build_args)
if (output_file == "") {
for ((_, log_path) <- results)
Output.writeln(log_path.implode, stdout = true)
}
else {
File.write(Path.explode(output_file),
cat_lines(for ((_, log_path) <- results) yield log_path.implode))
}
val rc = (0 /: results) { case (rc, (res, _)) => rc max res.rc }
if (rc != 0 && exit_code) sys.exit(rc)
}
}
/** remote build_history -- via command-line **/
def remote_build_history(
ssh: SSH.Session,
isabelle_repos_self: Path,
isabelle_repos_other: Path,
isabelle_repos_source: String = Isabelle_Cronjob.isabelle_repos_source,
afp_repos_source: String = AFP.repos_source,
isabelle_identifier: String = "remote_build_history",
self_update: Boolean = false,
progress: Progress = new Progress,
rev: String = "",
afp_rev: Option[String] = None,
options: String = "",
args: String = ""): List[(String, Bytes)] =
{
/* Isabelle self repository */
val self_hg =
Mercurial.setup_repository(isabelle_repos_source, isabelle_repos_self, ssh = ssh)
def execute(cmd: String, args: String, echo: Boolean = false, strict: Boolean = true): Unit =
ssh.execute(
Isabelle_System.export_isabelle_identifier(isabelle_identifier) +
ssh.bash_path(isabelle_repos_self + Path.explode(cmd)) + " " + args,
progress_stdout = progress.echo_if(echo, _),
progress_stderr = progress.echo_if(echo, _),
strict = strict).check
if (self_update) {
val hg = Mercurial.repository(Path.explode("~~"))
hg.push(self_hg.root_url, force = true)
self_hg.update(rev = hg.parent(), clean = true)
execute("bin/isabelle", "components -I")
execute("bin/isabelle", "components -a", echo = true)
execute("Admin/build", "jars_fresh")
}
val rev_id = self_hg.id(rev)
/* Isabelle other + AFP repository */
if (Mercurial.is_repository(isabelle_repos_other, ssh = ssh)) {
ssh.rm_tree(isabelle_repos_other)
}
Mercurial.clone_repository(
ssh.bash_path(isabelle_repos_self), isabelle_repos_other, rev = rev_id, ssh = ssh)
val afp_options =
if (afp_rev.isEmpty) ""
else {
val afp_repos = isabelle_repos_other + Path.explode("AFP")
Mercurial.setup_repository(afp_repos_source, afp_repos, ssh = ssh)
" -A " + Bash.string(afp_rev.get)
}
/* Admin/build_history */
ssh.with_tmp_dir(tmp_dir =>
{
val output_file = tmp_dir + Path.explode("output")
val rev_options = if (rev == "") "" else " -r " + Bash.string(rev_id)
try {
execute("Admin/build_history",
"-o " + ssh.bash_path(output_file) + rev_options + afp_options + " " + options + " " +
ssh.bash_path(isabelle_repos_other) + " " + args,
echo = true, strict = false)
}
catch {
case ERROR(msg) =>
cat_error(msg,
"The error(s) above occurred for build_bistory " + rev_options + afp_options)
}
for (line <- split_lines(ssh.read(output_file)))
yield {
val log = Path.explode(line)
val bytes = ssh.read_bytes(log)
ssh.rm(log)
(log.file_name, bytes)
}
})
}
}
diff --git a/src/Pure/Admin/build_jdk.scala b/src/Pure/Admin/build_jdk.scala
--- a/src/Pure/Admin/build_jdk.scala
+++ b/src/Pure/Admin/build_jdk.scala
@@ -1,241 +1,241 @@
/* Title: Pure/Admin/build_jdk.scala
Author: Makarius
Build Isabelle jdk component from original platform installations.
*/
package isabelle
import java.io.{File => JFile}
import java.nio.file.Files
import java.nio.file.attribute.PosixFilePermission
import scala.util.matching.Regex
object Build_JDK
{
/* platform and version information */
sealed case class JDK_Platform(
platform_name: String,
platform_regex: Regex,
exe: String = "java",
macos_home: Boolean = false,
jdk_version: String = "")
{
override def toString: String = platform_name
def platform_path: Path = Path.explode(platform_name)
def detect(jdk_dir: Path): Option[JDK_Platform] =
{
val major_version =
{
val Major_Version = """.*jdk(\d+).*$""".r
val jdk_name = jdk_dir.file.getName
jdk_name match {
case Major_Version(s) => s
case _ => error("Cannot determine major version from " + quote(jdk_name))
}
}
val path = jdk_dir + Path.explode("bin") + Path.explode(exe)
if (path.is_file) {
val file_descr = Isabelle_System.bash("file -b " + File.bash_path(path)).check.out
if (platform_regex.pattern.matcher(file_descr).matches) {
val Version = ("^(" + major_version + """\.[0-9.]+\+\d+)(?:-LTS)?$""").r
val version_lines =
Isabelle_System.bash("strings " + File.bash_path(path)).check
.out_lines.flatMap({ case Version(s) => Some(s) case _ => None })
version_lines match {
case List(jdk_version) => Some(copy(jdk_version = jdk_version))
case _ => error("Expected unique version within executable " + path)
}
}
else None
}
else None
}
}
val templates: List[JDK_Platform] =
List(
JDK_Platform("arm64-darwin", """.*Mach-O 64-bit.*arm64.*""".r, macos_home = true),
JDK_Platform("arm64-linux", """.*ELF 64-bit.*ARM aarch64.*""".r),
JDK_Platform("x86_64-darwin", """.*Mach-O 64-bit.*x86[-_]64.*""".r, macos_home = true),
JDK_Platform("x86_64-linux", """.*ELF 64-bit.*x86[-_]64.*""".r),
JDK_Platform("x86_64-windows", """.*PE32\+ executable.*x86[-_]64.*""".r, exe = "java.exe"))
/* README */
def readme(jdk_version: String): String =
"""This is OpenJDK """ + jdk_version + """ based on downloads by Azul, see also
https://www.azul.com/downloads/zulu-community/?package=jdk
The main license is GPL2, but some modules are covered by other (more liberal)
licenses, see legal/* for details.
Linux, Windows, macOS all work uniformly, depending on platform-specific
subdirectories.
"""
/* settings */
val settings: String =
"""# -*- shell-script -*- :mode=shellscript:
case "$ISABELLE_PLATFORM_FAMILY" in
linux)
ISABELLE_JAVA_PLATFORM="$ISABELLE_PLATFORM64"
ISABELLE_JDK_HOME="$COMPONENT/$ISABELLE_JAVA_PLATFORM"
;;
windows)
ISABELLE_JAVA_PLATFORM="$ISABELLE_WINDOWS_PLATFORM64"
ISABELLE_JDK_HOME="$COMPONENT/$ISABELLE_JAVA_PLATFORM"
;;
macos)
if [ -n "$ISABELLE_APPLE_PLATFORM64" -a -d "$COMPONENT/$ISABELLE_APPLE_PLATFORM64" ]
then
ISABELLE_JAVA_PLATFORM="$ISABELLE_APPLE_PLATFORM64"
else
ISABELLE_JAVA_PLATFORM="$ISABELLE_PLATFORM64"
fi
ISABELLE_JDK_HOME="$COMPONENT/$ISABELLE_JAVA_PLATFORM"
;;
esac
"""
/* extract archive */
def extract_archive(dir: Path, archive: Path): JDK_Platform =
{
try {
val tmp_dir = Isabelle_System.make_directory(dir + Path.explode("tmp"))
if (archive.get_ext == "zip") {
Isabelle_System.bash(
"unzip -x " + File.bash_path(archive.absolute), cwd = tmp_dir.file).check
}
else {
Isabelle_System.gnutar("-xzf " + File.bash_path(archive), dir = tmp_dir).check
}
val dir_entry =
File.read_dir(tmp_dir) match {
case List(s) => s
case _ => error("Archive contains multiple directories")
}
val jdk_dir = tmp_dir + Path.explode(dir_entry)
val platform =
templates.view.flatMap(_.detect(jdk_dir))
.headOption.getOrElse(error("Failed to detect JDK platform"))
val platform_dir = dir + platform.platform_path
if (platform_dir.is_dir) error("Directory already exists: " + platform_dir)
Isabelle_System.move_file(jdk_dir, platform_dir)
platform
}
catch { case ERROR(msg) => cat_error(msg, "The error(s) above occurred for " + archive) }
}
/* build jdk */
def build_jdk(
archives: List[Path],
progress: Progress = new Progress,
- target_dir: Path = Path.current)
+ target_dir: Path = Path.current): Unit =
{
if (Platform.is_windows) error("Cannot build jdk on Windows")
Isabelle_System.with_tmp_dir("jdk")(dir =>
{
progress.echo("Extracting ...")
val platforms = archives.map(extract_archive(dir, _))
val jdk_version =
platforms.map(_.jdk_version).distinct match {
case List(version) => version
case Nil => error("No archives")
case versions =>
error("Archives contain multiple JDK versions: " + commas_quote(versions))
}
templates.filterNot(p1 => platforms.exists(p2 => p1.platform_name == p2.platform_name))
match {
case Nil =>
case missing => error("Missing platforms: " + commas_quote(missing.map(_.platform_name)))
}
val jdk_name = "jdk-" + jdk_version
val jdk_path = Path.explode(jdk_name)
val component_dir = dir + jdk_path
Isabelle_System.make_directory(component_dir + Path.explode("etc"))
File.write(Components.settings(component_dir), settings)
File.write(component_dir + Path.explode("README"), readme(jdk_version))
for (platform <- platforms) {
Isabelle_System.move_file(dir + platform.platform_path, component_dir)
}
for (file <- File.find_files(component_dir.file, include_dirs = true)) {
val path = file.toPath
val perms = Files.getPosixFilePermissions(path)
perms.add(PosixFilePermission.OWNER_READ)
perms.add(PosixFilePermission.GROUP_READ)
perms.add(PosixFilePermission.OTHERS_READ)
perms.add(PosixFilePermission.OWNER_WRITE)
if (file.isDirectory) {
perms.add(PosixFilePermission.OWNER_WRITE)
perms.add(PosixFilePermission.OWNER_EXECUTE)
perms.add(PosixFilePermission.GROUP_EXECUTE)
perms.add(PosixFilePermission.OTHERS_EXECUTE)
}
Files.setPosixFilePermissions(path, perms)
}
progress.echo("Archiving ...")
Isabelle_System.gnutar(
"-czf " + File.bash_path(target_dir + jdk_path.ext("tar.gz")) + " " + jdk_name,
dir = dir).check
})
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_jdk", "build Isabelle jdk component from original archives",
Scala_Project.here, args =>
{
var target_dir = Path.current
val getopts = Getopts("""
Usage: isabelle build_jdk [OPTIONS] ARCHIVES...
Options are:
-D DIR target directory (default ".")
Build jdk component from tar.gz archives, with original jdk archives
for Linux, Windows, and macOS.
""",
"D:" -> (arg => target_dir = Path.explode(arg)))
val more_args = getopts(args)
if (more_args.isEmpty) getopts.usage()
val archives = more_args.map(Path.explode)
val progress = new Console_Progress()
build_jdk(archives = archives, progress = progress, target_dir = target_dir)
})
}
diff --git a/src/Pure/Admin/build_log.scala b/src/Pure/Admin/build_log.scala
--- a/src/Pure/Admin/build_log.scala
+++ b/src/Pure/Admin/build_log.scala
@@ -1,1174 +1,1175 @@
/* Title: Pure/Admin/build_log.scala
Author: Makarius
Management of build log files and database storage.
*/
package isabelle
import java.io.{File => JFile}
import java.time.format.{DateTimeFormatter, DateTimeParseException}
import java.util.Locale
import scala.collection.immutable.SortedMap
import scala.collection.mutable
import scala.util.matching.Regex
object Build_Log
{
/** content **/
/* properties */
object Prop
{
val build_tags = SQL.Column.string("build_tags") // lines
val build_args = SQL.Column.string("build_args") // lines
val build_group_id = SQL.Column.string("build_group_id")
val build_id = SQL.Column.string("build_id")
val build_engine = SQL.Column.string("build_engine")
val build_host = SQL.Column.string("build_host")
val build_start = SQL.Column.date("build_start")
val build_end = SQL.Column.date("build_end")
val isabelle_version = SQL.Column.string("isabelle_version")
val afp_version = SQL.Column.string("afp_version")
val all_props: List[SQL.Column] =
List(build_tags, build_args, build_group_id, build_id, build_engine,
build_host, build_start, build_end, isabelle_version, afp_version)
}
/* settings */
object Settings
{
val ISABELLE_BUILD_OPTIONS = SQL.Column.string("ISABELLE_BUILD_OPTIONS")
val ML_PLATFORM = SQL.Column.string("ML_PLATFORM")
val ML_HOME = SQL.Column.string("ML_HOME")
val ML_SYSTEM = SQL.Column.string("ML_SYSTEM")
val ML_OPTIONS = SQL.Column.string("ML_OPTIONS")
val ml_settings = List(ML_PLATFORM, ML_HOME, ML_SYSTEM, ML_OPTIONS)
val all_settings = ISABELLE_BUILD_OPTIONS :: ml_settings
type Entry = (String, String)
type T = List[Entry]
object Entry
{
def unapply(s: String): Option[Entry] =
s.indexOf('=') match {
case -1 => None
case i =>
val a = s.substring(0, i)
val b = Library.perhaps_unquote(s.substring(i + 1))
Some((a, b))
}
def apply(a: String, b: String): String = a + "=" + quote(b)
def getenv(a: String): String = apply(a, Isabelle_System.getenv(a))
}
def show(): String =
cat_lines(
List(Entry.getenv("ISABELLE_TOOL_JAVA_OPTIONS"),
Entry.getenv(ISABELLE_BUILD_OPTIONS.name), "") :::
ml_settings.map(c => Entry.getenv(c.name)))
}
/* file names */
def log_date(date: Date): String =
String.format(Locale.ROOT, "%s.%05d",
DateTimeFormatter.ofPattern("yyyy-MM-dd").format(date.rep),
java.lang.Long.valueOf((date.time - date.midnight.time).ms / 1000))
def log_subdir(date: Date): Path =
Path.explode("log") + Path.explode(date.rep.getYear.toString)
def log_filename(engine: String, date: Date, more: List[String] = Nil): Path =
Path.explode((engine :: log_date(date) :: more).mkString("", "_", ".log"))
/** log file **/
def print_date(date: Date): String = Log_File.Date_Format(date)
object Log_File
{
/* log file */
def plain_name(name: String): String =
{
List(".log", ".log.gz", ".log.xz", ".gz", ".xz").find(name.endsWith) match {
case Some(s) => Library.try_unsuffix(s, name).get
case None => name
}
}
def apply(name: String, lines: List[String]): Log_File =
new Log_File(plain_name(name), lines.map(Library.trim_line))
def apply(name: String, text: String): Log_File =
new Log_File(plain_name(name), Library.trim_split_lines(text))
def apply(file: JFile): Log_File =
{
val name = file.getName
val text =
if (name.endsWith(".gz")) File.read_gzip(file)
else if (name.endsWith(".xz")) File.read_xz(file)
else File.read(file)
apply(name, text)
}
def apply(path: Path): Log_File = apply(path.file)
/* log file collections */
def is_log(file: JFile,
prefixes: List[String] =
List(Build_History.log_prefix, Identify.log_prefix, Identify.log_prefix2,
Isatest.log_prefix, AFP_Test.log_prefix, Jenkins.log_prefix),
suffixes: List[String] = List(".log", ".log.gz", ".log.xz")): Boolean =
{
val name = file.getName
prefixes.exists(name.startsWith) &&
suffixes.exists(name.endsWith) &&
name != "isatest.log" &&
name != "afp-test.log" &&
name != "main.log"
}
/* date format */
val Date_Format =
{
val fmts =
Date.Formatter.variants(
List("EEE MMM d HH:mm:ss O yyyy", "EEE MMM d HH:mm:ss VV yyyy"),
List(Locale.ENGLISH, Locale.GERMAN)) :::
List(
DateTimeFormatter.RFC_1123_DATE_TIME,
Date.Formatter.pattern("EEE MMM d HH:mm:ss yyyy").withZone(Date.timezone_berlin))
def tune_timezone(s: String): String =
s match {
case "CET" | "MET" => "GMT+1"
case "CEST" | "MEST" => "GMT+2"
case "EST" => "Europe/Berlin"
case _ => s
}
def tune_weekday(s: String): String =
s match {
case "Die" => "Di"
case "Mit" => "Mi"
case "Don" => "Do"
case "Fre" => "Fr"
case "Sam" => "Sa"
case "Son" => "So"
case _ => s
}
def tune(s: String): String =
Word.implode(
Word.explode(s) match {
case a :: "M\uFFFDr" :: bs => tune_weekday(a) :: "Mär" :: bs.map(tune_timezone)
case a :: bs => tune_weekday(a) :: bs.map(tune_timezone)
case Nil => Nil
}
)
Date.Format.make(fmts, tune)
}
}
class Log_File private(val name: String, val lines: List[String])
{
log_file =>
override def toString: String = name
def text: String = cat_lines(lines)
def err(msg: String): Nothing =
error("Error in log file " + quote(name) + ": " + msg)
/* date format */
object Strict_Date
{
def unapply(s: String): Some[Date] =
try { Some(Log_File.Date_Format.parse(s)) }
catch { case exn: DateTimeParseException => log_file.err(exn.getMessage) }
}
/* inlined text */
def filter(Marker: Protocol_Message.Marker): List[String] =
for (Marker(text) <- lines) yield text
def find(Marker: Protocol_Message.Marker): Option[String] =
lines.collectFirst({ case Marker(text) => text })
def find_match(regexes: List[Regex]): Option[String] =
regexes match {
case Nil => None
case regex :: rest =>
lines.iterator.map(regex.unapplySeq(_)).find(res => res.isDefined && res.get.length == 1).
map(res => res.get.head) orElse find_match(rest)
}
/* settings */
def get_setting(a: String): Option[Settings.Entry] =
lines.find(_.startsWith(a + "=")) match {
case Some(line) => Settings.Entry.unapply(line)
case None => None
}
def get_all_settings: Settings.T =
for { c <- Settings.all_settings; entry <- get_setting(c.name) }
yield entry
/* properties (YXML) */
val cache: XML.Cache = XML.Cache.make()
def parse_props(text: String): Properties.T =
try { cache.props(XML.Decode.properties(YXML.parse_body(text))) }
catch { case _: XML.Error => log_file.err("malformed properties") }
def filter_props(marker: Protocol_Message.Marker): List[Properties.T] =
for (text <- filter(marker) if YXML.detect(text)) yield parse_props(text)
def find_props(marker: Protocol_Message.Marker): Option[Properties.T] =
for (text <- find(marker) if YXML.detect(text)) yield parse_props(text)
/* parse various formats */
def parse_meta_info(): Meta_Info = Build_Log.parse_meta_info(log_file)
def parse_build_info(ml_statistics: Boolean = false): Build_Info =
Build_Log.parse_build_info(log_file, ml_statistics)
def parse_session_info(
command_timings: Boolean = false,
theory_timings: Boolean = false,
ml_statistics: Boolean = false,
task_statistics: Boolean = false): Session_Info =
Build_Log.parse_session_info(
log_file, command_timings, theory_timings, ml_statistics, task_statistics)
}
/** digested meta info: produced by Admin/build_history in log.xz file **/
object Meta_Info
{
val empty: Meta_Info = Meta_Info(Nil, Nil)
}
sealed case class Meta_Info(props: Properties.T, settings: Settings.T)
{
def is_empty: Boolean = props.isEmpty && settings.isEmpty
def get(c: SQL.Column): Option[String] =
Properties.get(props, c.name) orElse
Properties.get(settings, c.name)
def get_date(c: SQL.Column): Option[Date] =
get(c).map(Log_File.Date_Format.parse)
}
object Identify
{
val log_prefix = "isabelle_identify_"
val log_prefix2 = "plain_identify_"
def engine(log_file: Log_File): String =
if (log_file.name.startsWith(Jenkins.log_prefix)) "jenkins_identify"
else if (log_file.name.startsWith(log_prefix2)) "plain_identify"
else "identify"
def content(date: Date, isabelle_version: Option[String], afp_version: Option[String]): String =
terminate_lines(
List("isabelle_identify: " + Build_Log.print_date(date), "") :::
isabelle_version.map("Isabelle version: " + _).toList :::
afp_version.map("AFP version: " + _).toList)
val Start = new Regex("""^isabelle_identify: (.+)$""")
val No_End = new Regex("""$.""")
val Isabelle_Version = List(new Regex("""^Isabelle version: (\S+)$"""))
val AFP_Version = List(new Regex("""^AFP version: (\S+)$"""))
}
object Isatest
{
val log_prefix = "isatest-makeall-"
val engine = "isatest"
val Start = new Regex("""^------------------- starting test --- (.+) --- (.+)$""")
val End = new Regex("""^------------------- test (?:successful|FAILED) --- (.+) --- .*$""")
val Isabelle_Version = List(new Regex("""^Isabelle version: (\S+)$"""))
}
object AFP_Test
{
val log_prefix = "afp-test-devel-"
val engine = "afp-test"
val Start = new Regex("""^Start test(?: for .+)? at ([^,]+), (.*)$""")
val Start_Old = new Regex("""^Start test(?: for .+)? at ([^,]+)$""")
val End = new Regex("""^End test on (.+), .+, elapsed time:.*$""")
val Isabelle_Version = List(new Regex("""^Isabelle version: .* -- hg id (\S+)$"""))
val AFP_Version = List(new Regex("""^AFP version: .* -- hg id (\S+)$"""))
val Bad_Init = new Regex("""^cp:.*: Disc quota exceeded$""")
}
object Jenkins
{
val log_prefix = "jenkins_"
val engine = "jenkins"
val Host = new Regex("""^Building remotely on (\S+) \((\S+)\).*$""")
val Start = new Regex("""^(?:Started by an SCM change|Started from command line by admin|).*$""")
val Start_Date = new Regex("""^Build started at (.+)$""")
val No_End = new Regex("""$.""")
val Isabelle_Version =
List(new Regex("""^(?:Build for Isabelle id|Isabelle id) (\w+).*$"""),
new Regex("""^ISABELLE_CI_REPO_ID="(\w+)".*$"""),
new Regex("""^(\w{12}) tip.*$"""))
val AFP_Version =
List(new Regex("""^(?:Build for AFP id|AFP id) (\w+).*$"""),
new Regex("""^ISABELLE_CI_AFP_ID="(\w+)".*$"""))
val CONFIGURATION = "=== CONFIGURATION ==="
val BUILD = "=== BUILD ==="
}
private def parse_meta_info(log_file: Log_File): Meta_Info =
{
def parse(engine: String, host: String, start: Date,
End: Regex, Isabelle_Version: List[Regex], AFP_Version: List[Regex]): Meta_Info =
{
val build_id =
{
val prefix = proper_string(host) orElse proper_string(engine) getOrElse "build"
prefix + ":" + start.time.ms
}
val build_engine = if (engine == "") Nil else List(Prop.build_engine.name -> engine)
val build_host = if (host == "") Nil else List(Prop.build_host.name -> host)
val start_date = List(Prop.build_start.name -> print_date(start))
val end_date =
log_file.lines.last match {
case End(log_file.Strict_Date(end_date)) =>
List(Prop.build_end.name -> print_date(end_date))
case _ => Nil
}
val isabelle_version =
log_file.find_match(Isabelle_Version).map(Prop.isabelle_version.name -> _)
val afp_version =
log_file.find_match(AFP_Version).map(Prop.afp_version.name -> _)
Meta_Info((Prop.build_id.name -> build_id) :: build_engine ::: build_host :::
start_date ::: end_date ::: isabelle_version.toList ::: afp_version.toList,
log_file.get_all_settings)
}
log_file.lines match {
case line :: _ if Protocol.Meta_Info_Marker.test_yxml(line) =>
Meta_Info(log_file.find_props(Protocol.Meta_Info_Marker).get, log_file.get_all_settings)
case Identify.Start(log_file.Strict_Date(start)) :: _ =>
parse(Identify.engine(log_file), "", start, Identify.No_End,
Identify.Isabelle_Version, Identify.AFP_Version)
case Isatest.Start(log_file.Strict_Date(start), host) :: _ =>
parse(Isatest.engine, host, start, Isatest.End,
Isatest.Isabelle_Version, Nil)
case AFP_Test.Start(log_file.Strict_Date(start), host) :: _ =>
parse(AFP_Test.engine, host, start, AFP_Test.End,
AFP_Test.Isabelle_Version, AFP_Test.AFP_Version)
case AFP_Test.Start_Old(log_file.Strict_Date(start)) :: _ =>
parse(AFP_Test.engine, "", start, AFP_Test.End,
AFP_Test.Isabelle_Version, AFP_Test.AFP_Version)
case Jenkins.Start() :: _ =>
log_file.lines.dropWhile(_ != Jenkins.BUILD) match {
case Jenkins.BUILD :: _ :: Jenkins.Start_Date(log_file.Strict_Date(start)) :: _ =>
val host =
log_file.lines.takeWhile(_ != Jenkins.CONFIGURATION).collectFirst({
case Jenkins.Host(a, b) => a + "." + b
}).getOrElse("")
parse(Jenkins.engine, host, start.to(Date.timezone_berlin), Jenkins.No_End,
Jenkins.Isabelle_Version, Jenkins.AFP_Version)
case _ => Meta_Info.empty
}
case line :: _ if line.startsWith("\u0000") => Meta_Info.empty
case List(Isatest.End(_)) => Meta_Info.empty
case _ :: AFP_Test.Bad_Init() :: _ => Meta_Info.empty
case Nil => Meta_Info.empty
case _ => log_file.err("cannot detect log file format")
}
}
/** build info: toplevel output of isabelle build or Admin/build_history **/
val SESSION_NAME = "session_name"
object Session_Status extends Enumeration
{
val existing, finished, failed, cancelled = Value
}
sealed case class Session_Entry(
chapter: String = "",
groups: List[String] = Nil,
threads: Option[Int] = None,
timing: Timing = Timing.zero,
ml_timing: Timing = Timing.zero,
sources: Option[String] = None,
heap_size: Option[Long] = None,
status: Option[Session_Status.Value] = None,
errors: List[String] = Nil,
theory_timings: Map[String, Timing] = Map.empty,
ml_statistics: List[Properties.T] = Nil)
{
def proper_groups: Option[String] = if (groups.isEmpty) None else Some(cat_lines(groups))
def finished: Boolean = status == Some(Session_Status.finished)
def failed: Boolean = status == Some(Session_Status.failed)
}
object Build_Info
{
val sessions_dummy: Map[String, Session_Entry] =
Map("" -> Session_Entry(theory_timings = Map("" -> Timing.zero)))
}
sealed case class Build_Info(sessions: Map[String, Session_Entry])
{
def finished_sessions: List[String] = for ((a, b) <- sessions.toList if b.finished) yield a
def failed_sessions: List[String] = for ((a, b) <- sessions.toList if b.failed) yield a
}
private def parse_build_info(log_file: Log_File, parse_ml_statistics: Boolean): Build_Info =
{
object Chapter_Name
{
def unapply(s: String): Some[(String, String)] =
space_explode('/', s) match {
case List(chapter, name) => Some((chapter, name))
case _ => Some(("", s))
}
}
val Session_No_Groups = new Regex("""^Session (\S+)$""")
val Session_Groups = new Regex("""^Session (\S+) \((.*)\)$""")
val Session_Finished1 =
new Regex("""^Finished (\S+) \((\d+):(\d+):(\d+) elapsed time, (\d+):(\d+):(\d+) cpu time.*$""")
val Session_Finished2 =
new Regex("""^Finished ([^\s/]+) \((\d+):(\d+):(\d+) elapsed time.*$""")
val Session_Timing =
new Regex("""^Timing (\S+) \((\d+) threads, (\d+\.\d+)s elapsed time, (\d+\.\d+)s cpu time, (\d+\.\d+)s GC time.*$""")
val Session_Started = new Regex("""^(?:Running|Building) (\S+) \.\.\.$""")
val Sources = new Regex("""^Sources (\S+) (\S{""" + SHA1.digest_length + """})$""")
val Heap = new Regex("""^Heap (\S+) \((\d+) bytes\)$""")
object Theory_Timing
{
def unapply(line: String): Option[(String, (String, Timing))] =
Protocol.Theory_Timing_Marker.unapply(line.replace('~', '-')).map(log_file.parse_props)
match {
case Some((SESSION_NAME, session) :: props) =>
for (theory <- Markup.Name.unapply(props))
yield (session, theory -> Markup.Timing_Properties.parse(props))
case _ => None
}
}
var chapter = Map.empty[String, String]
var groups = Map.empty[String, List[String]]
var threads = Map.empty[String, Int]
var timing = Map.empty[String, Timing]
var ml_timing = Map.empty[String, Timing]
var started = Set.empty[String]
var sources = Map.empty[String, String]
var heap_sizes = Map.empty[String, Long]
var theory_timings = Map.empty[String, Map[String, Timing]]
var ml_statistics = Map.empty[String, List[Properties.T]]
var errors = Map.empty[String, List[String]]
def all_sessions: Set[String] =
chapter.keySet ++ groups.keySet ++ threads.keySet ++ timing.keySet ++ ml_timing.keySet ++
started ++ sources.keySet ++ heap_sizes.keySet ++
theory_timings.keySet ++ ml_statistics.keySet
for (line <- log_file.lines) {
line match {
case Session_No_Groups(Chapter_Name(chapt, name)) =>
chapter += (name -> chapt)
groups += (name -> Nil)
case Session_Groups(Chapter_Name(chapt, name), grps) =>
chapter += (name -> chapt)
groups += (name -> Word.explode(grps))
case Session_Started(name) =>
started += name
case Session_Finished1(name,
Value.Int(e1), Value.Int(e2), Value.Int(e3),
Value.Int(c1), Value.Int(c2), Value.Int(c3)) =>
val elapsed = Time.hms(e1, e2, e3)
val cpu = Time.hms(c1, c2, c3)
timing += (name -> Timing(elapsed, cpu, Time.zero))
case Session_Finished2(name,
Value.Int(e1), Value.Int(e2), Value.Int(e3)) =>
val elapsed = Time.hms(e1, e2, e3)
timing += (name -> Timing(elapsed, Time.zero, Time.zero))
case Session_Timing(name,
Value.Int(t), Value.Double(e), Value.Double(c), Value.Double(g)) =>
val elapsed = Time.seconds(e)
val cpu = Time.seconds(c)
val gc = Time.seconds(g)
ml_timing += (name -> Timing(elapsed, cpu, gc))
threads += (name -> t)
case Sources(name, s) =>
sources += (name -> s)
case Heap(name, Value.Long(size)) =>
heap_sizes += (name -> size)
case _ if Protocol.Theory_Timing_Marker.test_yxml(line) =>
line match {
case Theory_Timing(name, theory_timing) =>
theory_timings += (name -> (theory_timings.getOrElse(name, Map.empty) + theory_timing))
case _ => log_file.err("malformed theory_timing " + quote(line))
}
case _ if parse_ml_statistics && Protocol.ML_Statistics_Marker.test_yxml(line) =>
Protocol.ML_Statistics_Marker.unapply(line).map(log_file.parse_props) match {
case Some((SESSION_NAME, name) :: props) =>
ml_statistics += (name -> (props :: ml_statistics.getOrElse(name, Nil)))
case _ => log_file.err("malformed ML_statistics " + quote(line))
}
case _ if Protocol.Error_Message_Marker.test_yxml(line) =>
Protocol.Error_Message_Marker.unapply(line).map(log_file.parse_props) match {
case Some(List((SESSION_NAME, name), (Markup.CONTENT, msg))) =>
errors += (name -> (msg :: errors.getOrElse(name, Nil)))
case _ => log_file.err("malformed error message " + quote(line))
}
case _ =>
}
}
val sessions =
Map(
(for (name <- all_sessions.toList) yield {
val status =
if (timing.isDefinedAt(name) || ml_timing.isDefinedAt(name))
Session_Status.finished
else if (started(name)) Session_Status.failed
else Session_Status.existing
val entry =
Session_Entry(
chapter = chapter.getOrElse(name, ""),
groups = groups.getOrElse(name, Nil),
threads = threads.get(name),
timing = timing.getOrElse(name, Timing.zero),
ml_timing = ml_timing.getOrElse(name, Timing.zero),
sources = sources.get(name),
heap_size = heap_sizes.get(name),
status = Some(status),
errors = errors.getOrElse(name, Nil).reverse,
theory_timings = theory_timings.getOrElse(name, Map.empty),
ml_statistics = ml_statistics.getOrElse(name, Nil).reverse)
(name -> entry)
}):_*)
Build_Info(sessions)
}
/** session info: produced by isabelle build as session database **/
sealed case class Session_Info(
session_timing: Properties.T,
command_timings: List[Properties.T],
theory_timings: List[Properties.T],
ml_statistics: List[Properties.T],
task_statistics: List[Properties.T],
errors: List[String])
{
def error(s: String): Session_Info =
copy(errors = errors ::: List(s))
}
private def parse_session_info(
log_file: Log_File,
command_timings: Boolean,
theory_timings: Boolean,
ml_statistics: Boolean,
task_statistics: Boolean): Session_Info =
{
Session_Info(
session_timing = log_file.find_props(Protocol.Session_Timing_Marker) getOrElse Nil,
command_timings =
if (command_timings) log_file.filter_props(Protocol.Command_Timing_Marker) else Nil,
theory_timings =
if (theory_timings) log_file.filter_props(Protocol.Theory_Timing_Marker) else Nil,
ml_statistics =
if (ml_statistics) log_file.filter_props(Protocol.ML_Statistics_Marker) else Nil,
task_statistics =
if (task_statistics) log_file.filter_props(Protocol.Task_Statistics_Marker) else Nil,
errors = log_file.filter(Protocol.Error_Message_Marker))
}
def compress_errors(errors: List[String], cache: XZ.Cache = XZ.Cache()): Option[Bytes] =
if (errors.isEmpty) None
else {
Some(Bytes(YXML.string_of_body(XML.Encode.list(XML.Encode.string)(errors))).
compress(cache = cache))
}
def uncompress_errors(bytes: Bytes, cache: XML.Cache = XML.Cache.make()): List[String] =
if (bytes.is_empty) Nil
else {
XML.Decode.list(YXML.string_of_body)(
YXML.parse_body(bytes.uncompress(cache = cache.xz).text, cache = cache))
}
/** persistent store **/
/* SQL data model */
object Data
{
def build_log_table(name: String, columns: List[SQL.Column], body: String = ""): SQL.Table =
SQL.Table("isabelle_build_log_" + name, columns, body)
/* main content */
val log_name = SQL.Column.string("log_name").make_primary_key
val session_name = SQL.Column.string("session_name").make_primary_key
val theory_name = SQL.Column.string("theory_name").make_primary_key
val chapter = SQL.Column.string("chapter")
val groups = SQL.Column.string("groups")
val threads = SQL.Column.int("threads")
val timing_elapsed = SQL.Column.long("timing_elapsed")
val timing_cpu = SQL.Column.long("timing_cpu")
val timing_gc = SQL.Column.long("timing_gc")
val timing_factor = SQL.Column.double("timing_factor")
val ml_timing_elapsed = SQL.Column.long("ml_timing_elapsed")
val ml_timing_cpu = SQL.Column.long("ml_timing_cpu")
val ml_timing_gc = SQL.Column.long("ml_timing_gc")
val ml_timing_factor = SQL.Column.double("ml_timing_factor")
val theory_timing_elapsed = SQL.Column.long("theory_timing_elapsed")
val theory_timing_cpu = SQL.Column.long("theory_timing_cpu")
val theory_timing_gc = SQL.Column.long("theory_timing_gc")
val heap_size = SQL.Column.long("heap_size")
val status = SQL.Column.string("status")
val errors = SQL.Column.bytes("errors")
val sources = SQL.Column.string("sources")
val ml_statistics = SQL.Column.bytes("ml_statistics")
val known = SQL.Column.bool("known")
val meta_info_table =
build_log_table("meta_info", log_name :: Prop.all_props ::: Settings.all_settings)
val sessions_table =
build_log_table("sessions",
List(log_name, session_name, chapter, groups, threads, timing_elapsed, timing_cpu,
timing_gc, timing_factor, ml_timing_elapsed, ml_timing_cpu, ml_timing_gc, ml_timing_factor,
heap_size, status, errors, sources))
val theories_table =
build_log_table("theories",
List(log_name, session_name, theory_name, theory_timing_elapsed, theory_timing_cpu,
theory_timing_gc))
val ml_statistics_table =
build_log_table("ml_statistics", List(log_name, session_name, ml_statistics))
/* AFP versions */
val isabelle_afp_versions_table: SQL.Table =
{
val version1 = Prop.isabelle_version
val version2 = Prop.afp_version
build_log_table("isabelle_afp_versions", List(version1.make_primary_key, version2),
SQL.select(List(version1, version2), distinct = true) + meta_info_table +
" WHERE " + version1.defined + " AND " + version2.defined)
}
/* earliest pull date for repository version (PostgreSQL queries) */
def pull_date(afp: Boolean = false): SQL.Column =
if (afp) SQL.Column.date("afp_pull_date")
else SQL.Column.date("pull_date")
def pull_date_table(afp: Boolean = false): SQL.Table =
{
val (name, versions) =
if (afp) ("afp_pull_date", List(Prop.isabelle_version, Prop.afp_version))
else ("pull_date", List(Prop.isabelle_version))
build_log_table(name, versions.map(_.make_primary_key) ::: List(pull_date(afp)),
"SELECT " + versions.mkString(", ") +
", min(" + Prop.build_start + ") AS " + pull_date(afp) +
" FROM " + meta_info_table +
" WHERE " + (versions ::: List(Prop.build_start)).map(_.defined).mkString(" AND ") +
" GROUP BY " + versions.mkString(", "))
}
/* recent entries */
def recent_time(days: Int): SQL.Source =
"now() - INTERVAL '" + days.max(0) + " days'"
def recent_pull_date_table(
days: Int, rev: String = "", afp_rev: Option[String] = None): SQL.Table =
{
val afp = afp_rev.isDefined
val rev2 = afp_rev.getOrElse("")
val table = pull_date_table(afp)
val version1 = Prop.isabelle_version
val version2 = Prop.afp_version
val eq1 = version1(table) + " = " + SQL.string(rev)
val eq2 = version2(table) + " = " + SQL.string(rev2)
SQL.Table("recent_pull_date", table.columns,
table.select(table.columns,
"WHERE " + pull_date(afp)(table) + " > " + recent_time(days) +
(if (rev != "" && rev2 == "") " OR " + eq1
else if (rev == "" && rev2 != "") " OR " + eq2
else if (rev != "" && rev2 != "") " OR (" + eq1 + " AND " + eq2 + ")"
else "")))
}
def select_recent_log_names(days: Int): SQL.Source =
{
val table1 = meta_info_table
val table2 = recent_pull_date_table(days)
table1.select(List(log_name), distinct = true) + SQL.join_inner + table2.query_named +
" ON " + Prop.isabelle_version(table1) + " = " + Prop.isabelle_version(table2)
}
def select_recent_versions(days: Int,
rev: String = "", afp_rev: Option[String] = None, sql: SQL.Source = ""): SQL.Source =
{
val afp = afp_rev.isDefined
val version = Prop.isabelle_version
val table1 = recent_pull_date_table(days, rev = rev, afp_rev = afp_rev)
val table2 = meta_info_table
val aux_table = SQL.Table("aux", table2.columns, table2.select(sql = sql))
val columns =
table1.columns.map(c => c(table1)) :::
List(known.copy(expr = log_name(aux_table).defined))
SQL.select(columns, distinct = true) +
table1.query_named + SQL.join_outer + aux_table.query_named +
" ON " + version(table1) + " = " + version(aux_table) +
" ORDER BY " + pull_date(afp)(table1) + " DESC"
}
/* universal view on main data */
val universal_table: SQL.Table =
{
val afp_pull_date = pull_date(afp = true)
val version1 = Prop.isabelle_version
val version2 = Prop.afp_version
val table1 = meta_info_table
val table2 = pull_date_table(afp = true)
val table3 = pull_date_table()
val a_columns = log_name :: afp_pull_date :: table1.columns.tail
val a_table =
SQL.Table("a", a_columns,
SQL.select(List(log_name, afp_pull_date) ::: table1.columns.tail.map(_.apply(table1))) +
table1 + SQL.join_outer + table2 +
" ON " + version1(table1) + " = " + version1(table2) +
" AND " + version2(table1) + " = " + version2(table2))
val b_columns = log_name :: pull_date() :: a_columns.tail
val b_table =
SQL.Table("b", b_columns,
SQL.select(
List(log_name(a_table), pull_date()(table3)) ::: a_columns.tail.map(_.apply(a_table))) +
a_table.query_named + SQL.join_outer + table3 +
" ON " + version1(a_table) + " = " + version1(table3))
val c_columns = b_columns ::: sessions_table.columns.tail
val c_table =
SQL.Table("c", c_columns,
SQL.select(log_name(b_table) :: c_columns.tail) +
b_table.query_named + SQL.join_inner + sessions_table +
" ON " + log_name(b_table) + " = " + log_name(sessions_table))
SQL.Table("isabelle_build_log", c_columns ::: List(ml_statistics),
{
SQL.select(c_columns.map(_.apply(c_table)) ::: List(ml_statistics)) +
c_table.query_named + SQL.join_outer + ml_statistics_table +
" ON " + log_name(c_table) + " = " + log_name(ml_statistics_table) +
" AND " + session_name(c_table) + " = " + session_name(ml_statistics_table)
})
}
}
/* database access */
def store(options: Options, cache: XML.Cache = XML.Cache.make()): Store =
new Store(options, cache)
class Store private[Build_Log](options: Options, val cache: XML.Cache)
{
def open_database(
user: String = options.string("build_log_database_user"),
password: String = options.string("build_log_database_password"),
database: String = options.string("build_log_database_name"),
host: String = options.string("build_log_database_host"),
port: Int = options.int("build_log_database_port"),
ssh_host: String = options.string("build_log_ssh_host"),
ssh_user: String = options.string("build_log_ssh_user"),
ssh_port: Int = options.int("build_log_ssh_port")): PostgreSQL.Database =
{
PostgreSQL.open_database(
user = user, password = password, database = database, host = host, port = port,
ssh =
if (ssh_host == "") None
else Some(SSH.open_session(options, host = ssh_host, user = ssh_user, port = ssh_port)),
ssh_close = true)
}
- def update_database(db: PostgreSQL.Database, dirs: List[Path], ml_statistics: Boolean = false)
+ def update_database(
+ db: PostgreSQL.Database, dirs: List[Path], ml_statistics: Boolean = false): Unit =
{
val log_files =
dirs.flatMap(dir =>
File.find_files(dir.file, pred = Log_File.is_log(_), follow_links = true))
write_info(db, log_files, ml_statistics = ml_statistics)
db.create_view(Data.pull_date_table())
db.create_view(Data.pull_date_table(afp = true))
db.create_view(Data.universal_table)
}
def snapshot_database(db: PostgreSQL.Database, sqlite_database: Path,
- days: Int = 100, ml_statistics: Boolean = false)
+ days: Int = 100, ml_statistics: Boolean = false): Unit =
{
Isabelle_System.make_directory(sqlite_database.dir)
sqlite_database.file.delete
using(SQLite.open_database(sqlite_database))(db2 =>
{
db.transaction {
db2.transaction {
// main content
db2.create_table(Data.meta_info_table)
db2.create_table(Data.sessions_table)
db2.create_table(Data.theories_table)
db2.create_table(Data.ml_statistics_table)
val recent_log_names =
db.using_statement(Data.select_recent_log_names(days))(stmt =>
stmt.execute_query().iterator(_.string(Data.log_name)).toList)
for (log_name <- recent_log_names) {
read_meta_info(db, log_name).foreach(meta_info =>
update_meta_info(db2, log_name, meta_info))
update_sessions(db2, log_name, read_build_info(db, log_name))
if (ml_statistics) {
update_ml_statistics(db2, log_name,
read_build_info(db, log_name, ml_statistics = true))
}
}
// pull_date
for (afp <- List(false, true))
{
val afp_rev = if (afp) Some("") else None
val table = Data.pull_date_table(afp)
db2.create_table(table)
db2.using_statement(table.insert())(stmt2 =>
{
db.using_statement(
Data.recent_pull_date_table(days, afp_rev = afp_rev).query)(stmt =>
{
val res = stmt.execute_query()
while (res.next()) {
for ((c, i) <- table.columns.zipWithIndex) {
stmt2.string(i + 1) = res.get_string(c)
}
stmt2.execute()
}
})
})
}
// full view
db2.create_view(Data.universal_table)
}
}
db2.rebuild
})
}
def domain(db: SQL.Database, table: SQL.Table, column: SQL.Column): Set[String] =
db.using_statement(table.select(List(column), distinct = true))(stmt =>
stmt.execute_query().iterator(_.string(column)).toSet)
- def update_meta_info(db: SQL.Database, log_name: String, meta_info: Meta_Info)
+ def update_meta_info(db: SQL.Database, log_name: String, meta_info: Meta_Info): Unit =
{
val table = Data.meta_info_table
db.using_statement(db.insert_permissive(table))(stmt =>
{
stmt.string(1) = log_name
for ((c, i) <- table.columns.tail.zipWithIndex) {
if (c.T == SQL.Type.Date)
stmt.date(i + 2) = meta_info.get_date(c)
else
stmt.string(i + 2) = meta_info.get(c)
}
stmt.execute()
})
}
- def update_sessions(db: SQL.Database, log_name: String, build_info: Build_Info)
+ def update_sessions(db: SQL.Database, log_name: String, build_info: Build_Info): Unit =
{
val table = Data.sessions_table
db.using_statement(db.insert_permissive(table))(stmt =>
{
val sessions =
if (build_info.sessions.isEmpty) Build_Info.sessions_dummy
else build_info.sessions
for ((session_name, session) <- sessions) {
stmt.string(1) = log_name
stmt.string(2) = session_name
stmt.string(3) = proper_string(session.chapter)
stmt.string(4) = session.proper_groups
stmt.int(5) = session.threads
stmt.long(6) = session.timing.elapsed.proper_ms
stmt.long(7) = session.timing.cpu.proper_ms
stmt.long(8) = session.timing.gc.proper_ms
stmt.double(9) = session.timing.factor
stmt.long(10) = session.ml_timing.elapsed.proper_ms
stmt.long(11) = session.ml_timing.cpu.proper_ms
stmt.long(12) = session.ml_timing.gc.proper_ms
stmt.double(13) = session.ml_timing.factor
stmt.long(14) = session.heap_size
stmt.string(15) = session.status.map(_.toString)
stmt.bytes(16) = compress_errors(session.errors, cache = cache.xz)
stmt.string(17) = session.sources
stmt.execute()
}
})
}
- def update_theories(db: SQL.Database, log_name: String, build_info: Build_Info)
+ def update_theories(db: SQL.Database, log_name: String, build_info: Build_Info): Unit =
{
val table = Data.theories_table
db.using_statement(db.insert_permissive(table))(stmt =>
{
val sessions =
if (build_info.sessions.forall({ case (_, session) => session.theory_timings.isEmpty }))
Build_Info.sessions_dummy
else build_info.sessions
for {
(session_name, session) <- sessions
(theory_name, timing) <- session.theory_timings
} {
stmt.string(1) = log_name
stmt.string(2) = session_name
stmt.string(3) = theory_name
stmt.long(4) = timing.elapsed.ms
stmt.long(5) = timing.cpu.ms
stmt.long(6) = timing.gc.ms
stmt.execute()
}
})
}
- def update_ml_statistics(db: SQL.Database, log_name: String, build_info: Build_Info)
+ def update_ml_statistics(db: SQL.Database, log_name: String, build_info: Build_Info): Unit =
{
val table = Data.ml_statistics_table
db.using_statement(db.insert_permissive(table))(stmt =>
{
val ml_stats: List[(String, Option[Bytes])] =
Par_List.map[(String, Session_Entry), (String, Option[Bytes])](
{ case (a, b) => (a, Properties.compress(b.ml_statistics, cache = cache.xz).proper) },
build_info.sessions.iterator.filter(p => p._2.ml_statistics.nonEmpty).toList)
val entries = if (ml_stats.nonEmpty) ml_stats else List("" -> None)
for ((session_name, ml_statistics) <- entries) {
stmt.string(1) = log_name
stmt.string(2) = session_name
stmt.bytes(3) = ml_statistics
stmt.execute()
}
})
}
- def write_info(db: SQL.Database, files: List[JFile], ml_statistics: Boolean = false)
+ def write_info(db: SQL.Database, files: List[JFile], ml_statistics: Boolean = false): Unit =
{
abstract class Table_Status(table: SQL.Table)
{
db.create_table(table)
private var known: Set[String] = domain(db, table, Data.log_name)
def required(file: JFile): Boolean = !known(Log_File.plain_name(file.getName))
def update_db(db: SQL.Database, log_file: Log_File): Unit
- def update(log_file: Log_File)
+ def update(log_file: Log_File): Unit =
{
if (!known(log_file.name)) {
update_db(db, log_file)
known += log_file.name
}
}
}
val status =
List(
new Table_Status(Data.meta_info_table) {
override def update_db(db: SQL.Database, log_file: Log_File): Unit =
update_meta_info(db, log_file.name, log_file.parse_meta_info())
},
new Table_Status(Data.sessions_table) {
override def update_db(db: SQL.Database, log_file: Log_File): Unit =
update_sessions(db, log_file.name, log_file.parse_build_info())
},
new Table_Status(Data.theories_table) {
override def update_db(db: SQL.Database, log_file: Log_File): Unit =
update_theories(db, log_file.name, log_file.parse_build_info())
},
new Table_Status(Data.ml_statistics_table) {
override def update_db(db: SQL.Database, log_file: Log_File): Unit =
if (ml_statistics) {
update_ml_statistics(db, log_file.name,
log_file.parse_build_info(ml_statistics = true))
}
})
for (file_group <-
files.filter(file => status.exists(_.required(file))).
grouped(options.int("build_log_transaction_size") max 1))
{
val log_files = Par_List.map[JFile, Log_File](Log_File.apply, file_group)
db.transaction { log_files.foreach(log_file => status.foreach(_.update(log_file))) }
}
}
def read_meta_info(db: SQL.Database, log_name: String): Option[Meta_Info] =
{
val table = Data.meta_info_table
val columns = table.columns.tail
db.using_statement(table.select(columns, Data.log_name.where_equal(log_name)))(stmt =>
{
val res = stmt.execute_query()
if (!res.next) None
else {
val results =
columns.map(c => c.name ->
(if (c.T == SQL.Type.Date)
res.get_date(c).map(Log_File.Date_Format(_))
else
res.get_string(c)))
val n = Prop.all_props.length
val props = for ((x, Some(y)) <- results.take(n)) yield (x, y)
val settings = for ((x, Some(y)) <- results.drop(n)) yield (x, y)
Some(Meta_Info(props, settings))
}
})
}
def read_build_info(
db: SQL.Database,
log_name: String,
session_names: List[String] = Nil,
ml_statistics: Boolean = false): Build_Info =
{
val table1 = Data.sessions_table
val table2 = Data.ml_statistics_table
val where_log_name =
Data.log_name(table1).where_equal(log_name) + " AND " +
Data.session_name(table1) + " <> ''"
val where =
if (session_names.isEmpty) where_log_name
else where_log_name + " AND " + SQL.member(Data.session_name(table1).ident, session_names)
val columns1 = table1.columns.tail.map(_.apply(table1))
val (columns, from) =
if (ml_statistics) {
val columns = columns1 ::: List(Data.ml_statistics(table2))
val join =
table1 + SQL.join_outer + table2 + " ON " +
Data.log_name(table1) + " = " + Data.log_name(table2) + " AND " +
Data.session_name(table1) + " = " + Data.session_name(table2)
(columns, SQL.enclose(join))
}
else (columns1, table1.ident)
val sessions =
db.using_statement(SQL.select(columns) + from + " " + where)(stmt =>
{
stmt.execute_query().iterator(res =>
{
val session_name = res.string(Data.session_name)
val session_entry =
Session_Entry(
chapter = res.string(Data.chapter),
groups = split_lines(res.string(Data.groups)),
threads = res.get_int(Data.threads),
timing = res.timing(Data.timing_elapsed, Data.timing_cpu, Data.timing_gc),
ml_timing =
res.timing(Data.ml_timing_elapsed, Data.ml_timing_cpu, Data.ml_timing_gc),
sources = res.get_string(Data.sources),
heap_size = res.get_long(Data.heap_size),
status = res.get_string(Data.status).map(Session_Status.withName),
errors = uncompress_errors(res.bytes(Data.errors), cache = cache),
ml_statistics =
if (ml_statistics) {
Properties.uncompress(res.bytes(Data.ml_statistics), cache = cache)
}
else Nil)
session_name -> session_entry
}).toMap
})
Build_Info(sessions)
}
}
}
diff --git a/src/Pure/Admin/build_polyml.scala b/src/Pure/Admin/build_polyml.scala
--- a/src/Pure/Admin/build_polyml.scala
+++ b/src/Pure/Admin/build_polyml.scala
@@ -1,270 +1,270 @@
/* Title: Pure/Admin/build_polyml.scala
Author: Makarius
Build Poly/ML from sources.
*/
package isabelle
import scala.util.matching.Regex
object Build_PolyML
{
/** platform-specific build **/
sealed case class Platform_Info(
options: List[String] = Nil,
setup: String = "",
libs: Set[String] = Set.empty)
private val platform_info = Map(
"linux" ->
Platform_Info(
options = List("LDFLAGS=-Wl,-rpath,_DUMMY_"),
libs = Set("libgmp")),
"darwin" ->
Platform_Info(
options =
List("--build=x86_64-darwin", "CFLAGS=-arch x86_64 -O3 -I../libffi/include",
"CXXFLAGS=-arch x86_64 -O3 -I../libffi/include", "CCASFLAGS=-arch x86_64",
"LDFLAGS=-segprot POLY rwx rwx"),
setup = "PATH=/usr/bin:/bin:/usr/sbin:/sbin",
libs = Set("libpolyml", "libgmp")),
"windows" ->
Platform_Info(
options =
List("--host=x86_64-w64-mingw32", "CPPFLAGS=-I/mingw64/include", "--disable-windows-gui"),
setup = MinGW.environment_export,
libs = Set("libgcc_s_seh", "libgmp", "libstdc++", "libwinpthread")))
def build_polyml(
root: Path,
sha1_root: Option[Path] = None,
progress: Progress = new Progress,
arch_64: Boolean = false,
options: List[String] = Nil,
- mingw: MinGW = MinGW.none)
+ mingw: MinGW = MinGW.none): Unit =
{
if (!((root + Path.explode("configure")).is_file && (root + Path.explode("PolyML")).is_dir))
error("Bad Poly/ML root directory: " + root)
val platform = Isabelle_Platform.self
val platform_arch =
if (arch_64) platform.arch_64
else if (platform.is_intel) "x86_64_32"
else platform.arch_32
val polyml_platform = platform_arch + "-" + platform.os_name
val sha1_platform = platform.arch_64 + "-" + platform.os_name
val info =
platform_info.getOrElse(platform.os_name,
error("Bad OS platform: " + quote(platform.os_name)))
if (platform.is_linux) Isabelle_System.require_command("chrpath")
/* bash */
def bash(
cwd: Path, script: String, redirect: Boolean = false, echo: Boolean = false): Process_Result =
{
progress.bash(mingw.bash_script(script), cwd = cwd.file, redirect = redirect, echo = echo)
}
/* configure and make */
val configure_options =
List("--disable-shared", "--enable-intinf-as-int", "--with-gmp") :::
info.options ::: options ::: (if (arch_64) Nil else List("--enable-compact32bit"))
bash(root,
info.setup + "\n" +
"""
[ -f Makefile ] && make distclean
{
./configure --prefix="$PWD/target" """ + Bash.strings(configure_options) + """
rm -rf target
make compiler && make compiler && make install
} || { echo "Build failed" >&2; exit 2; }
""", redirect = true, echo = true).check
/* sha1 library */
val sha1_files =
if (sha1_root.isDefined) {
val dir1 = sha1_root.get
bash(dir1, "./build " + sha1_platform, redirect = true, echo = true).check
val dir2 = dir1 + Path.explode(sha1_platform)
File.read_dir(dir2).map(entry => dir2 + Path.basic(entry))
}
else Nil
/* install */
val platform_dir = Path.explode(polyml_platform)
Isabelle_System.rm_tree(platform_dir)
Isabelle_System.make_directory(platform_dir)
for (file <- sha1_files) Isabelle_System.copy_file(file, platform_dir)
for {
d <- List("target/bin", "target/lib")
dir = root + Path.explode(d)
entry <- File.read_dir(dir)
} Isabelle_System.move_file(dir + Path.explode(entry), platform_dir)
Executable.libraries_closure(
platform_dir + Path.basic("poly").platform_exe, mingw = mingw, filter = info.libs)
/* polyc: directory prefix */
val Header = "#! */bin/sh".r
File.change(platform_dir + Path.explode("polyc"), txt =>
split_lines(txt) match {
case Header() :: lines =>
val lines1 =
lines.map(line =>
if (line.startsWith("prefix=")) "prefix=\"$(cd \"$(dirname \"$0\")\"; pwd)\""
else if (line.startsWith("BINDIR=")) "BINDIR=\"$prefix\""
else if (line.startsWith("LIBDIR=")) "LIBDIR=\"$prefix\""
else line)
cat_lines("#!/usr/bin/env bash" ::lines1)
case lines =>
error(cat_lines("Cannot patch polyc -- undetected header:" :: lines.take(3)))
}
)
}
/** skeleton for component **/
- private def extract_sources(source_archive: Path, component_dir: Path)
+ private def extract_sources(source_archive: Path, component_dir: Path): Unit =
{
if (source_archive.get_ext == "zip") {
Isabelle_System.bash(
"unzip -x " + File.bash_path(source_archive.absolute), cwd = component_dir.file).check
}
else {
Isabelle_System.gnutar("-xzf " + File.bash_path(source_archive), dir = component_dir).check
}
val src_dir = component_dir + Path.explode("src")
File.read_dir(component_dir) match {
case List(s) => Isabelle_System.move_file(component_dir + Path.basic(s), src_dir)
case _ => error("Source archive contains multiple directories")
}
val lines = split_lines(File.read(src_dir + Path.explode("RootX86.ML")))
val ml_files =
for {
line <- lines
rest <- Library.try_unprefix("use", line)
} yield "ML_file" + rest
File.write(src_dir + Path.explode("ROOT.ML"),
"""(* Poly/ML Compiler root file.
When this file is open in the Prover IDE, the ML files of the Poly/ML
compiler can be explored interactively. This is a separate copy: it does
not affect the running ML session. *)
""" + ml_files.mkString("\n", "\n", "\n"))
}
def build_polyml_component(
source_archive: Path,
component_dir: Path,
- sha1_root: Option[Path] = None)
+ sha1_root: Option[Path] = None): Unit =
{
Isabelle_System.new_directory(component_dir)
extract_sources(source_archive, component_dir)
Isabelle_System.copy_file(Path.explode("~~/Admin/polyml/README"), component_dir)
val etc_dir = Isabelle_System.make_directory(component_dir + Path.explode("etc"))
Isabelle_System.copy_file(Path.explode("~~/Admin/polyml/settings"), etc_dir)
sha1_root match {
case Some(dir) =>
Mercurial.repository(dir).archive(File.standard_path(component_dir + Path.explode("sha1")))
case None =>
}
}
/** Isabelle tool wrappers **/
val isabelle_tool1 =
Isabelle_Tool("build_polyml", "build Poly/ML from sources", Scala_Project.here, args =>
{
var mingw = MinGW.none
var arch_64 = Isabelle_Platform.self.is_arm
var sha1_root: Option[Path] = None
val getopts = Getopts("""
Usage: isabelle build_polyml [OPTIONS] ROOT [CONFIGURE_OPTIONS]
Options are:
-M DIR msys/mingw root specification for Windows
-m ARCH processor architecture (32 or 64, default: """ +
(if (arch_64) "64" else "32") + """)
-s DIR sha1 sources, see https://isabelle.sketis.net/repos/sha1
Build Poly/ML in the ROOT directory of its sources, with additional
CONFIGURE_OPTIONS (e.g. --without-gmp).
""",
"M:" -> (arg => mingw = MinGW(Path.explode(arg))),
"m:" ->
{
case "32" => arch_64 = false
case "64" => arch_64 = true
case bad => error("Bad processor architecture: " + quote(bad))
},
"s:" -> (arg => sha1_root = Some(Path.explode(arg))))
val more_args = getopts(args)
val (root, options) =
more_args match {
case root :: options => (Path.explode(root), options)
case Nil => getopts.usage()
}
build_polyml(root, sha1_root = sha1_root, progress = new Console_Progress,
arch_64 = arch_64, options = options, mingw = mingw)
})
val isabelle_tool2 =
Isabelle_Tool("build_polyml_component", "make skeleton for Poly/ML component",
Scala_Project.here, args =>
{
var sha1_root: Option[Path] = None
val getopts = Getopts("""
Usage: isabelle build_polyml_component [OPTIONS] SOURCE_ARCHIVE COMPONENT_DIR
Options are:
-s DIR sha1 sources, see https://isabelle.sketis.net/repos/sha1
Make skeleton for Poly/ML component, based on official source archive
(zip or tar.gz).
""",
"s:" -> (arg => sha1_root = Some(Path.explode(arg))))
val more_args = getopts(args)
val (source_archive, component_dir) =
more_args match {
case List(archive, dir) => (Path.explode(archive), Path.explode(dir))
case _ => getopts.usage()
}
build_polyml_component(source_archive, component_dir, sha1_root = sha1_root)
})
}
diff --git a/src/Pure/Admin/build_release.scala b/src/Pure/Admin/build_release.scala
--- a/src/Pure/Admin/build_release.scala
+++ b/src/Pure/Admin/build_release.scala
@@ -1,927 +1,928 @@
/* Title: Pure/Admin/build_release.scala
Author: Makarius
Build full Isabelle distribution from repository.
*/
package isabelle
object Build_Release
{
/** release info **/
sealed case class Bundle_Info(
platform: Platform.Family.Value,
platform_description: String,
name: String)
{
def path: Path = Path.explode(name)
}
class Release private[Build_Release](
progress: Progress,
val date: Date,
val dist_name: String,
val dist_dir: Path,
val dist_version: String,
val ident: String)
{
val isabelle_dir: Path = dist_dir + Path.explode(dist_name)
val isabelle_archive: Path = dist_dir + Path.explode(dist_name + ".tar.gz")
val isabelle_library_archive: Path = dist_dir + Path.explode(dist_name + "_library.tar.gz")
def other_isabelle(dir: Path): Other_Isabelle =
Other_Isabelle(dir + Path.explode(dist_name),
isabelle_identifier = dist_name + "-build",
progress = progress)
def bundle_info(platform: Platform.Family.Value): Bundle_Info =
platform match {
case Platform.Family.linux => Bundle_Info(platform, "Linux", dist_name + "_linux.tar.gz")
case Platform.Family.macos => Bundle_Info(platform, "macOS", dist_name + "_macos.tar.gz")
case Platform.Family.windows => Bundle_Info(platform, "Windows", dist_name + ".exe")
}
}
/** generated content **/
/* patch release */
private val getsettings_path = Path.explode("lib/scripts/getsettings")
private val ISABELLE_ID = """ISABELLE_ID="(.+)"""".r
- def patch_release(release: Release, is_official: Boolean)
+ def patch_release(release: Release, is_official: Boolean): Unit =
{
val dir = release.isabelle_dir
for (name <- List("src/Pure/System/distribution.ML", "src/Pure/System/distribution.scala"))
{
File.change(dir + Path.explode(name),
_.replace("val is_identified = false", "val is_identified = true")
.replace("val is_official = false", "val is_official = " + is_official))
}
File.change(dir + getsettings_path,
_.replace("ISABELLE_ID=\"\"", "ISABELLE_ID=" + quote(release.ident))
.replace("ISABELLE_IDENTIFIER=\"\"", "ISABELLE_IDENTIFIER=" + quote(release.dist_name)))
File.change(dir + Path.explode("lib/html/library_index_header.template"),
_.replace("{ISABELLE}", release.dist_name))
for {
name <-
List(
"src/Pure/System/distribution.ML",
"src/Pure/System/distribution.scala",
"lib/Tools/version") }
{
File.change(dir + Path.explode(name), _.replace("repository version", release.dist_version))
}
File.change(dir + Path.explode("README"),
_.replace("some repository version of Isabelle", release.dist_version))
}
/* ANNOUNCE */
- def make_announce(release: Release)
+ def make_announce(release: Release): Unit =
{
File.write(release.isabelle_dir + Path.explode("ANNOUNCE"),
"""
IMPORTANT NOTE
==============
This is a snapshot of Isabelle/""" + release.ident + """ from the repository.
""")
}
/* NEWS */
- def make_news(other_isabelle: Other_Isabelle, dist_version: String)
+ def make_news(other_isabelle: Other_Isabelle, dist_version: String): Unit =
{
val target = other_isabelle.isabelle_home + Path.explode("doc")
val target_fonts = Isabelle_System.make_directory(target + Path.explode("fonts"))
other_isabelle.copy_fonts(target_fonts)
HTML.write_document(target, "NEWS.html",
List(HTML.title("NEWS (" + dist_version + ")")),
List(
HTML.chapter("NEWS"),
HTML.source(
Symbol.decode(File.read(other_isabelle.isabelle_home + Path.explode("NEWS"))))))
}
/* bundled components */
class Bundled(platform: Option[Platform.Family.Value] = None)
{
def detect(s: String): Boolean =
s.startsWith("#bundled") && !s.startsWith("#bundled ")
def apply(name: String): String =
"#bundled" + (platform match { case None => "" case Some(plat) => "-" + plat }) + ":" + name
private val Pattern1 = ("""^#bundled:(.*)$""").r
private val Pattern2 = ("""^#bundled-(.*):(.*)$""").r
def unapply(s: String): Option[String] =
s match {
case Pattern1(name) => Some(name)
case Pattern2(Platform.Family(plat), name) if platform == Some(plat) => Some(name)
case _ => None
}
}
- def record_bundled_components(dir: Path)
+ def record_bundled_components(dir: Path): Unit =
{
val catalogs =
List("main", "bundled").map((_, new Bundled())) :::
default_platform_families.flatMap(platform =>
List(platform.toString, "bundled-" + platform.toString).
map((_, new Bundled(platform = Some(platform)))))
File.append(Components.components(dir),
terminate_lines("#bundled components" ::
(for {
(catalog, bundled) <- catalogs.iterator
path = Components.admin(dir) + Path.basic(catalog)
if path.is_file
line <- split_lines(File.read(path))
if line.nonEmpty && !line.startsWith("#") && !line.startsWith("jedit_build")
} yield bundled(line)).toList))
}
def get_bundled_components(dir: Path, platform: Platform.Family.Value): (List[String], String) =
{
val Bundled = new Bundled(platform = Some(platform))
val components =
for {
Bundled(name) <- Components.read_components(dir)
if !name.startsWith("jedit_build")
} yield name
val jdk_component =
components.find(_.startsWith("jdk")) getOrElse error("Missing jdk component")
(components, jdk_component)
}
- def activate_components(dir: Path, platform: Platform.Family.Value, more_names: List[String])
+ def activate_components(
+ dir: Path, platform: Platform.Family.Value, more_names: List[String]): Unit =
{
def contrib_name(name: String): String =
Components.contrib(name = name).implode
val Bundled = new Bundled(platform = Some(platform))
Components.write_components(dir,
Components.read_components(dir).flatMap(line =>
line match {
case Bundled(name) =>
if (Components.check_dir(Components.contrib(dir, name))) Some(contrib_name(name))
else None
case _ => if (Bundled.detect(line)) None else Some(line)
}) ::: more_names.map(contrib_name))
}
- def make_contrib(dir: Path)
+ def make_contrib(dir: Path): Unit =
{
Isabelle_System.make_directory(Components.contrib(dir))
File.write(Components.contrib(dir, "README"),
"""This directory contains add-on components that contribute to the main
Isabelle distribution. Separate licensing conditions apply, see each
directory individually.
""")
}
/** build release **/
private def execute(dir: Path, script: String): Unit =
Isabelle_System.bash(script, cwd = dir.file).check
private def execute_tar(dir: Path, args: String): Unit =
Isabelle_System.gnutar(args, dir = dir).check
/* build heaps on remote server */
private def remote_build_heaps(
options: Options,
platform: Platform.Family.Value,
build_sessions: List[String],
- local_dir: Path)
+ local_dir: Path): Unit =
{
val server_option = "build_host_" + platform.toString
options.string(server_option) match {
case SSH.Target(user, host) =>
using(SSH.open_session(options, host = host, user = user))(ssh =>
{
Isabelle_System.with_tmp_file("tmp", "tar")(local_tmp_tar =>
{
execute_tar(local_dir, "-cf " + File.bash_path(local_tmp_tar) + " .")
ssh.with_tmp_dir(remote_dir =>
{
val remote_tmp_tar = remote_dir + Path.basic("tmp.tar")
ssh.write_file(remote_tmp_tar, local_tmp_tar)
val remote_commands =
List(
"cd " + File.bash_path(remote_dir),
"tar -xf tmp.tar",
"./bin/isabelle build -o system_heaps -b -- " + Bash.strings(build_sessions),
"tar -cf tmp.tar heaps")
ssh.execute(remote_commands.mkString(" && ")).check
ssh.read_file(remote_tmp_tar, local_tmp_tar)
})
execute_tar(local_dir, "-xf " + File.bash_path(local_tmp_tar))
})
})
case s => error("Bad " + server_option + ": " + quote(s))
}
}
/* Isabelle application */
- def make_isabelle_options(path: Path, options: List[String], line_ending: String = "\n")
+ def make_isabelle_options(path: Path, options: List[String], line_ending: String = "\n"): Unit =
{
val title = "# Java runtime options"
File.write(path, (title :: options).map(_ + line_ending).mkString)
}
def make_isabelle_app(
platform: Platform.Family.Value,
isabelle_target: Path,
isabelle_name: String,
jdk_component: String,
classpath: List[Path],
- dock_icon: Boolean = false)
+ dock_icon: Boolean = false): Unit =
{
val script = """#!/usr/bin/env bash
#
# Author: Makarius
#
# Main Isabelle application script.
# minimal Isabelle environment
ISABELLE_HOME="$(cd "$(dirname "$0")"; cd "$(pwd -P)/../.."; pwd)"
source "$ISABELLE_HOME/lib/scripts/isabelle-platform"
#paranoia settings -- avoid intrusion of alien options
unset "_JAVA_OPTIONS"
unset "JAVA_TOOL_OPTIONS"
#paranoia settings -- avoid problems of Java/Swing versus XIM/IBus etc.
unset XMODIFIERS
COMPONENT="$ISABELLE_HOME/contrib/""" + jdk_component + """"
source "$COMPONENT/etc/settings"
# main
declare -a JAVA_OPTIONS=($(perl -p -e 's,#.*$,,g;' "$ISABELLE_HOME/Isabelle.options"))
"$ISABELLE_HOME/bin/isabelle" env "$ISABELLE_HOME/lib/scripts/java-gui-setup"
exec "$ISABELLE_JDK_HOME/bin/java" \
"-Disabelle.root=$ISABELLE_HOME" "${JAVA_OPTIONS[@]}" \
-classpath """" + classpath.map(p => "$ISABELLE_HOME/" + p.implode).mkString(":") + """" \
"-splash:$ISABELLE_HOME/lib/logo/isabelle.gif" \
""" + (if (dock_icon) """"-Xdock:icon=$ISABELLE_HOME/lib/logo/isabelle_transparent-128.png" \
""" else "") + """isabelle.Main "$@"
"""
val script_path = isabelle_target + Path.explode("lib/scripts/Isabelle_app")
File.write(script_path, script)
File.set_executable(script_path, true)
val component_dir = isabelle_target + Path.explode("contrib/Isabelle_app")
Isabelle_System.move_file(
component_dir + Path.explode(Platform.standard_platform(platform)) + Path.explode("Isabelle"),
isabelle_target + Path.explode(isabelle_name))
Isabelle_System.rm_tree(component_dir)
}
- def make_isabelle_plist(path: Path, isabelle_name: String, isabelle_rev: String)
+ def make_isabelle_plist(path: Path, isabelle_name: String, isabelle_rev: String): Unit =
{
File.write(path, """
CFBundleDevelopmentRegion
English
CFBundleIconFile
isabelle.icns
CFBundleIdentifier
de.tum.in.isabelle
CFBundleDisplayName
""" + isabelle_name + """
CFBundleInfoDictionaryVersion
6.0
CFBundleName
""" + isabelle_name + """
CFBundlePackageType
APPL
CFBundleShortVersionString
""" + isabelle_name + """
CFBundleSignature
????
CFBundleVersion
""" + isabelle_rev + """
NSHumanReadableCopyright
LSMinimumSystemVersion
10.11
LSApplicationCategoryType
public.app-category.developer-tools
NSHighResolutionCapable
true
NSSupportsAutomaticGraphicsSwitching
true
CFBundleDocumentTypes
CFBundleTypeExtensions
thy
CFBundleTypeIconFile
theory.icns
CFBundleTypeName
Isabelle theory file
CFBundleTypeRole
Editor
LSTypeIsPackage
""")
}
/* main */
private val default_platform_families: List[Platform.Family.Value] =
List(Platform.Family.linux, Platform.Family.windows, Platform.Family.macos)
def build_release(base_dir: Path,
options: Options,
components_base: Path = Components.default_components_base,
progress: Progress = new Progress,
rev: String = "",
afp_rev: String = "",
official_release: Boolean = false,
proper_release_name: Option[String] = None,
platform_families: List[Platform.Family.Value] = default_platform_families,
more_components: List[Path] = Nil,
website: Option[Path] = None,
build_sessions: List[String] = Nil,
build_library: Boolean = false,
parallel_jobs: Int = 1): Release =
{
val hg = Mercurial.repository(Path.explode("$ISABELLE_HOME"))
val release =
{
val date = Date.now()
val dist_name = proper_release_name getOrElse ("Isabelle_" + Date.Format.date(date))
val dist_dir = (base_dir + Path.explode("dist-" + dist_name)).absolute
val version = proper_string(rev) orElse proper_release_name getOrElse "tip"
val ident =
try { hg.id(version) }
catch { case ERROR(msg) => cat_error("Bad repository version: " + version, msg) }
val dist_version =
proper_release_name match {
case Some(name) => name + ": " + Date.Format("LLLL uuuu")(date)
case None => "Isabelle repository snapshot " + ident + " " + Date.Format.date(date)
}
new Release(progress, date, dist_name, dist_dir, dist_version, ident)
}
/* make distribution */
if (release.isabelle_archive.is_file) {
progress.echo_warning("Release archive already exists: " + release.isabelle_archive)
val archive_ident =
Isabelle_System.with_tmp_dir("build_release")(tmp_dir =>
{
val getsettings = Path.explode(release.dist_name) + getsettings_path
execute_tar(tmp_dir, "-xzf " +
File.bash_path(release.isabelle_archive) + " " + File.bash_path(getsettings))
split_lines(File.read(tmp_dir + getsettings))
.collectFirst({ case ISABELLE_ID(ident) => ident })
.getOrElse(error("Failed to read ISABELLE_ID from " + release.isabelle_archive))
})
if (release.ident != archive_ident) {
error("Mismatch of release identification " + release.ident +
" vs. archive " + archive_ident)
}
}
else {
progress.echo_warning("Producing release archive " + release.isabelle_archive + " ...")
Isabelle_System.make_directory(release.dist_dir)
if (release.isabelle_dir.is_dir)
error("Directory " + release.isabelle_dir + " already exists")
progress.echo_warning("Retrieving Mercurial repository version " + release.ident)
hg.archive(release.isabelle_dir.expand.implode, rev = release.ident, options = "--type files")
for (name <- List(".hg_archival.txt", ".hgtags", ".hgignore", "README_REPOSITORY")) {
(release.isabelle_dir + Path.explode(name)).file.delete
}
progress.echo_warning("Preparing distribution " + quote(release.dist_name))
patch_release(release, proper_release_name.isDefined && official_release)
if (proper_release_name.isEmpty) make_announce(release)
make_contrib(release.isabelle_dir)
execute(release.isabelle_dir, """find . -print | xargs chmod -f u+rw""")
record_bundled_components(release.isabelle_dir)
/* build tools and documentation */
val other_isabelle = release.other_isabelle(release.dist_dir)
other_isabelle.init_settings(
other_isabelle.init_components(components_base = components_base, catalogs = List("main")))
other_isabelle.resolve_components(echo = true)
try {
val export_classpath =
"export CLASSPATH=" + Bash.string(other_isabelle.getenv("ISABELLE_CLASSPATH")) + "\n"
other_isabelle.bash(export_classpath + "./Admin/build all", echo = true).check
other_isabelle.bash(export_classpath + "./bin/isabelle jedit -b", echo = true).check
}
catch { case ERROR(msg) => cat_error("Failed to build tools:", msg) }
try {
other_isabelle.bash(
"./bin/isabelle build_doc -a -o system_heaps -j " + parallel_jobs, echo = true).check
}
catch { case ERROR(msg) => cat_error("Failed to build documentation:", msg) }
make_news(other_isabelle, release.dist_version)
for (name <- List("Admin", "browser_info", "heaps")) {
Isabelle_System.rm_tree(other_isabelle.isabelle_home + Path.explode(name))
}
other_isabelle.cleanup()
progress.echo_warning("Creating distribution archive " + release.isabelle_archive)
def execute_dist_name(script: String): Unit =
Isabelle_System.bash(script, cwd = release.dist_dir.file,
env = Isabelle_System.settings() + ("DIST_NAME" -> release.dist_name)).check
execute_dist_name("""
set -e
chmod -R a+r "$DIST_NAME"
chmod -R u+w "$DIST_NAME"
chmod -R g=o "$DIST_NAME"
find "$DIST_NAME" -type f "(" -name "*.thy" -o -name "*.ML" -o -name "*.scala" ")" -print | xargs chmod -f u-w
""")
execute_tar(release.dist_dir, "-czf " +
File.bash_path(release.isabelle_archive) + " " + Bash.string(release.dist_name))
execute_dist_name("""
set -e
mv "$DIST_NAME" "${DIST_NAME}-old"
mkdir "$DIST_NAME"
mv "${DIST_NAME}-old/README" "${DIST_NAME}-old/NEWS" "${DIST_NAME}-old/ANNOUNCE" \
"${DIST_NAME}-old/COPYRIGHT" "${DIST_NAME}-old/CONTRIBUTORS" "$DIST_NAME"
mkdir "$DIST_NAME/doc"
mv "${DIST_NAME}-old/doc/"*.pdf \
"${DIST_NAME}-old/doc/"*.html \
"${DIST_NAME}-old/doc/"*.css \
"${DIST_NAME}-old/doc/fonts" \
"${DIST_NAME}-old/doc/Contents" "$DIST_NAME/doc"
rm -f Isabelle && ln -sf "$DIST_NAME" Isabelle
rm -rf "${DIST_NAME}-old"
""")
}
/* make application bundles */
val bundle_infos = platform_families.map(release.bundle_info)
for (bundle_info <- bundle_infos) {
val isabelle_name = release.dist_name
val platform = bundle_info.platform
progress.echo("\nApplication bundle for " + platform)
Isabelle_System.with_tmp_dir("build_release")(tmp_dir =>
{
// release archive
execute_tar(tmp_dir, "-xzf " + File.bash_path(release.isabelle_archive))
val other_isabelle = release.other_isabelle(tmp_dir)
val isabelle_target = other_isabelle.isabelle_home
// bundled components
progress.echo("Bundled components:")
val contrib_dir = Components.contrib(isabelle_target)
val (bundled_components, jdk_component) =
get_bundled_components(isabelle_target, platform)
Components.resolve(components_base, bundled_components,
target_dir = Some(contrib_dir),
copy_dir = Some(release.dist_dir + Path.explode("contrib")),
progress = progress)
val more_components_names =
more_components.map(Components.unpack(contrib_dir, _, progress = progress))
Components.purge(contrib_dir, platform)
activate_components(isabelle_target, platform, more_components_names)
// Java parameters
val java_options: List[String] =
(for {
variable <-
List(
"ISABELLE_JAVA_SYSTEM_OPTIONS",
"JEDIT_JAVA_SYSTEM_OPTIONS",
"JEDIT_JAVA_OPTIONS")
opt <- Word.explode(other_isabelle.getenv(variable))
}
yield {
val s = "-Dapple.awt.application.name="
if (opt.startsWith(s)) s + isabelle_name else opt
}) ::: List("-Disabelle.jedit_server=" + isabelle_name)
val classpath: List[Path] =
{
val base = isabelle_target.absolute
Path.split(other_isabelle.getenv("ISABELLE_CLASSPATH")).map(path =>
{
val abs_path = path.absolute
File.relative_path(base, abs_path) match {
case Some(rel_path) => rel_path
case None => error("Bad ISABELLE_CLASSPATH element: " + abs_path)
}
}) ::: List(Path.explode("src/Tools/jEdit/dist/jedit.jar"))
}
val jedit_options = Path.explode("src/Tools/jEdit/etc/options")
val jedit_props = Path.explode("src/Tools/jEdit/dist/properties/jEdit.props")
// build heaps
if (build_sessions.nonEmpty) {
progress.echo("Building heaps ...")
remote_build_heaps(options, platform, build_sessions, isabelle_target)
}
// application bundling
platform match {
case Platform.Family.linux =>
File.change(isabelle_target + jedit_options,
_.replaceAll("jedit_reset_font_size : int =.*", "jedit_reset_font_size : int = 24"))
File.change(isabelle_target + jedit_props,
_.replaceAll("console.fontsize=.*", "console.fontsize=18")
.replaceAll("helpviewer.fontsize=.*", "helpviewer.fontsize=18")
.replaceAll("metal.primary.fontsize=.*", "metal.primary.fontsize=18")
.replaceAll("metal.secondary.fontsize=.*", "metal.secondary.fontsize=18")
.replaceAll("view.fontsize=.*", "view.fontsize=24")
.replaceAll("view.gutter.fontsize=.*", "view.gutter.fontsize=16"))
make_isabelle_options(
isabelle_target + Path.explode("Isabelle.options"), java_options)
make_isabelle_app(platform, isabelle_target, isabelle_name, jdk_component, classpath)
val archive_name = isabelle_name + "_linux.tar.gz"
progress.echo("Packaging " + archive_name + " ...")
execute_tar(tmp_dir,
"-czf " + File.bash_path(release.dist_dir + Path.explode(archive_name)) + " " +
Bash.string(isabelle_name))
case Platform.Family.macos =>
File.change(isabelle_target + jedit_props,
_.replaceAll("delete-line.shortcut=.*", "delete-line.shortcut=C+d")
.replaceAll("delete.shortcut2=.*", "delete.shortcut2=A+d"))
// macOS application bundle
val app_contents = isabelle_target + Path.explode("Contents")
for (icon <- List("lib/logo/isabelle.icns", "lib/logo/theory.icns")) {
Isabelle_System.copy_file(isabelle_target + Path.explode(icon),
Isabelle_System.make_directory(app_contents + Path.explode("Resources")))
}
make_isabelle_plist(
app_contents + Path.explode("Info.plist"), isabelle_name, release.ident)
make_isabelle_app(platform, isabelle_target, isabelle_name, jdk_component,
classpath, dock_icon = true)
val isabelle_options = Path.explode("Isabelle.options")
make_isabelle_options(
isabelle_target + isabelle_options,
java_options ::: List("-Disabelle.app=true"))
// application archive
val archive_name = isabelle_name + "_macos.tar.gz"
progress.echo("Packaging " + archive_name + " ...")
val isabelle_app = Path.explode(isabelle_name + ".app")
Isabelle_System.move_file(tmp_dir + Path.explode(isabelle_name),
tmp_dir + isabelle_app)
execute_tar(tmp_dir,
"-czf " + File.bash_path(release.dist_dir + Path.explode(archive_name)) + " " +
File.bash_path(isabelle_app))
case Platform.Family.windows =>
File.change(isabelle_target + jedit_props,
_.replaceAll("foldPainter=.*", "foldPainter=Square"))
// application launcher
Isabelle_System.move_file(isabelle_target + Path.explode("contrib/windows_app"), tmp_dir)
val app_template = Path.explode("~~/Admin/Windows/launch4j")
make_isabelle_options(
isabelle_target + Path.explode(isabelle_name + ".l4j.ini"),
java_options, line_ending = "\r\n")
val isabelle_xml = Path.explode("isabelle.xml")
val isabelle_exe = Path.explode(isabelle_name + ".exe")
File.write(tmp_dir + isabelle_xml,
File.read(app_template + isabelle_xml)
.replace("{ISABELLE_NAME}", isabelle_name)
.replace("{OUTFILE}", File.platform_path(isabelle_target + isabelle_exe))
.replace("{ICON}",
File.platform_path(app_template + Path.explode("isabelle_transparent.ico")))
.replace("{SPLASH}",
File.platform_path(app_template + Path.explode("isabelle.bmp")))
.replace("{CLASSPATH}",
cat_lines(classpath.map(cp =>
" %EXEDIR%\\" + File.platform_path(cp).replace('/', '\\') + "")))
.replace("\\jdk\\", "\\" + jdk_component + "\\"))
execute(tmp_dir,
"\"windows_app/launch4j-${ISABELLE_PLATFORM_FAMILY}/launch4j\" isabelle.xml")
Isabelle_System.copy_file(app_template + Path.explode("manifest.xml"),
isabelle_target + isabelle_exe.ext("manifest"))
// Cygwin setup
val cygwin_template = Path.explode("~~/Admin/Windows/Cygwin")
Isabelle_System.copy_file(cygwin_template + Path.explode("Cygwin-Terminal.bat"),
isabelle_target)
val cygwin_mirror =
File.read(isabelle_target + Path.explode("contrib/cygwin/isabelle/cygwin_mirror"))
val cygwin_bat = Path.explode("Cygwin-Setup.bat")
File.write(isabelle_target + cygwin_bat,
File.read(cygwin_template + cygwin_bat).replace("{MIRROR}", cygwin_mirror))
File.set_executable(isabelle_target + cygwin_bat, true)
for (name <- List("isabelle/postinstall", "isabelle/rebaseall")) {
val path = Path.explode(name)
Isabelle_System.copy_file(cygwin_template + path,
isabelle_target + Path.explode("contrib/cygwin") + path)
}
execute(isabelle_target,
"""find . -type f -not -name "*.exe" -not -name "*.dll" """ +
(if (Platform.is_macos) "-perm +100" else "-executable") +
" -print0 > contrib/cygwin/isabelle/executables")
execute(isabelle_target,
"""find . -type l -exec echo "{}" ";" -exec readlink "{}" ";" """ +
"""> contrib/cygwin/isabelle/symlinks""")
execute(isabelle_target, """find . -type l -exec rm "{}" ";" """)
File.write(isabelle_target + Path.explode("contrib/cygwin/isabelle/uninitialized"), "")
// executable archive (self-extracting 7z)
val archive_name = isabelle_name + ".7z"
val exe_archive = tmp_dir + Path.explode(archive_name)
exe_archive.file.delete
progress.echo("Packaging " + archive_name + " ...")
execute(tmp_dir,
"7z -y -bd a " + File.bash_path(exe_archive) + " " + Bash.string(isabelle_name))
if (!exe_archive.is_file) error("Failed to create archive: " + exe_archive)
val sfx_exe = tmp_dir + Path.explode("windows_app/7zsd_All_x64.sfx")
val sfx_txt =
File.read(Path.explode("~~/Admin/Windows/Installer/sfx.txt"))
.replace("{ISABELLE_NAME}", isabelle_name)
Bytes.write(release.dist_dir + isabelle_exe,
Bytes.read(sfx_exe) + Bytes(sfx_txt) + Bytes.read(exe_archive))
File.set_executable(release.dist_dir + isabelle_exe, true)
}
})
progress.echo("DONE")
}
/* minimal website */
for (dir <- website) {
val website_platform_bundles =
for {
bundle_info <- bundle_infos
if (release.dist_dir + bundle_info.path).is_file
} yield (bundle_info.name, bundle_info)
val isabelle_link =
HTML.link(Isabelle_Cronjob.isabelle_repos_source + "/rev/" + release.ident,
HTML.text("Isabelle/" + release.ident))
val afp_link =
HTML.link(AFP.repos_source + "/rev/" + afp_rev, HTML.text("AFP/" + afp_rev))
HTML.write_document(dir, "index.html",
List(HTML.title(release.dist_name)),
List(
HTML.section(release.dist_name),
HTML.subsection("Platforms"),
HTML.itemize(
website_platform_bundles.map({ case (bundle, bundle_info) =>
List(HTML.link(bundle, HTML.text(bundle_info.platform_description))) })),
HTML.subsection("Repositories"),
HTML.itemize(
List(List(isabelle_link)) ::: (if (afp_rev == "") Nil else List(List(afp_link))))))
for ((bundle, _) <- website_platform_bundles)
Isabelle_System.copy_file(release.dist_dir + Path.explode(bundle), dir)
}
/* HTML library */
if (build_library) {
if (release.isabelle_library_archive.is_file) {
progress.echo_warning("Library archive already exists: " + release.isabelle_library_archive)
}
else {
Isabelle_System.with_tmp_dir("build_release")(tmp_dir =>
{
val bundle =
release.dist_dir + Path.explode(release.dist_name + "_" + Platform.family + ".tar.gz")
execute_tar(tmp_dir, "-xzf " + File.bash_path(bundle))
val other_isabelle = release.other_isabelle(tmp_dir)
Isabelle_System.make_directory(other_isabelle.etc)
File.write(other_isabelle.etc_preferences, "ML_system_64 = true\n")
other_isabelle.bash("bin/isabelle build -f -j " + parallel_jobs +
" -o browser_info -o document=pdf -o document_variants=document:outline=/proof,/ML" +
" -o system_heaps -c -a -d '~~/src/Benchmarks'", echo = true).check
other_isabelle.isabelle_home_user.file.delete
execute(tmp_dir, "chmod -R a+r " + Bash.string(release.dist_name))
execute(tmp_dir, "chmod -R g=o " + Bash.string(release.dist_name))
execute_tar(tmp_dir, "-czf " + File.bash_path(release.isabelle_library_archive) +
" " + Bash.string(release.dist_name + "/browser_info"))
})
}
}
release
}
/** command line entry point **/
- def main(args: Array[String])
+ def main(args: Array[String]): Unit =
{
Command_Line.tool {
var afp_rev = ""
var components_base: Path = Components.default_components_base
var official_release = false
var proper_release_name: Option[String] = None
var website: Option[Path] = None
var build_sessions: List[String] = Nil
var more_components: List[Path] = Nil
var parallel_jobs = 1
var build_library = false
var options = Options.init()
var platform_families = default_platform_families
var rev = ""
val getopts = Getopts("""
Usage: Admin/build_release [OPTIONS] BASE_DIR
Options are:
-A REV corresponding AFP changeset id
-C DIR base directory for Isabelle components (default: """ +
Components.default_components_base + """)
-O official release (not release-candidate)
-R RELEASE proper release with name
-W WEBSITE produce minimal website in given directory
-b SESSIONS build platform-specific session images (separated by commas)
-c ARCHIVE clean bundling with additional component .tar.gz archive
-j INT maximum number of parallel jobs (default 1)
-l build library
-o OPTION override Isabelle system OPTION (via NAME=VAL or NAME)
-p NAMES platform families (default: """ + default_platform_families.mkString(",") + """)
-r REV Mercurial changeset id (default: RELEASE or tip)
Build Isabelle release in base directory, using the local repository clone.
""",
"A:" -> (arg => afp_rev = arg),
"C:" -> (arg => components_base = Path.explode(arg)),
"O" -> (_ => official_release = true),
"R:" -> (arg => proper_release_name = Some(arg)),
"W:" -> (arg => website = Some(Path.explode(arg))),
"b:" -> (arg => build_sessions = space_explode(',', arg)),
"c:" -> (arg =>
{
val path = Path.explode(arg)
Components.Archive.get_name(path.file_name)
more_components = more_components ::: List(path)
}),
"j:" -> (arg => parallel_jobs = Value.Int.parse(arg)),
"l" -> (_ => build_library = true),
"o:" -> (arg => options = options + arg),
"p:" -> (arg => platform_families = space_explode(',', arg).map(Platform.Family.parse)),
"r:" -> (arg => rev = arg))
val more_args = getopts(args)
val base_dir = more_args match { case List(base_dir) => base_dir case _ => getopts.usage() }
val progress = new Console_Progress()
if (platform_families.contains(Platform.Family.windows) && !Isabelle_System.bash("7z i").ok)
error("Building for windows requires 7z")
build_release(Path.explode(base_dir), options, components_base = components_base,
progress = progress, rev = rev, afp_rev = afp_rev, official_release = official_release,
proper_release_name = proper_release_name, website = website,
platform_families =
if (platform_families.isEmpty) default_platform_families
else platform_families,
more_components = more_components, build_sessions = build_sessions,
build_library = build_library, parallel_jobs = parallel_jobs)
}
}
}
diff --git a/src/Pure/Admin/build_spass.scala b/src/Pure/Admin/build_spass.scala
--- a/src/Pure/Admin/build_spass.scala
+++ b/src/Pure/Admin/build_spass.scala
@@ -1,180 +1,180 @@
/* Title: Pure/Admin/build_spass.scala
Author: Makarius
Build Isabelle SPASS component from unofficial download.
*/
package isabelle
object Build_SPASS
{
/* build SPASS */
val default_download_url = "https://www.cs.vu.nl/~jbe248/spass-3.8ds-src.tar.gz"
val standard_version = "3.8ds"
def build_spass(
download_url: String = default_download_url,
verbose: Boolean = false,
progress: Progress = new Progress,
- target_dir: Path = Path.current)
+ target_dir: Path = Path.current): Unit =
{
Isabelle_System.with_tmp_dir("build")(tmp_dir =>
{
Isabelle_System.require_command("bison", "flex")
/* component */
val Archive_Name = """^.*?([^/]+)$""".r
val Component_Name = """^(.+)-src\.tar.gz$""".r
val Version = """^[^-]+-([^-]+)$""".r
val (archive_name, archive_base_name) =
download_url match {
case Archive_Name(name) => (name, Library.perhaps_unsuffix(".tar.gz", name))
case _ => error("Failed to determine source archive name from " + quote(download_url))
}
val component_name =
archive_name match {
case Component_Name(name) => name
case _ => error("Failed to determine component name from " + quote(archive_name))
}
val version =
component_name match {
case Version(version) => version
case _ => error("Failed to determine component version from " + quote(component_name))
}
if (version != standard_version) {
progress.echo_warning("Odd SPASS version " + version + " (expected " + standard_version + ")")
}
val component_dir = Isabelle_System.new_directory(target_dir + Path.basic(component_name))
progress.echo("Component " + component_dir)
val platform_name =
proper_string(Isabelle_System.getenv("ISABELLE_PLATFORM64"))
.getOrElse(error("No 64bit platform"))
val platform_dir = Isabelle_System.make_directory(component_dir + Path.basic(platform_name))
/* download source */
val archive_path = tmp_dir + Path.basic(archive_name)
Isabelle_System.download(download_url, archive_path, progress = progress)
Isabelle_System.bash("tar xzf " + archive_path, cwd = tmp_dir.file).check
Isabelle_System.bash(
"tar xzf " + archive_path + " && mv " + Bash.string(archive_base_name) + " src",
cwd = component_dir.file).check
/* build */
progress.echo("Building SPASS for " + platform_name + " ...")
val build_dir = tmp_dir + Path.basic(archive_base_name)
if (Platform.is_windows) {
File.change(build_dir + Path.basic("misc.c"),
_.replace("""#include "execinfo.h" """, "")
.replaceAll("""void misc_DumpCore\(void\)[^}]+}""", "void misc_DumpCore(void) { abort(); }"))
}
Isabelle_System.bash("make",
cwd = build_dir.file,
progress_stdout = progress.echo_if(verbose, _),
progress_stderr = progress.echo_if(verbose, _)).check
/* install */
Isabelle_System.copy_file(build_dir + Path.basic("LICENCE"),
component_dir + Path.basic("LICENSE"))
val install_files = List("SPASS")
for (name <- install_files ::: install_files.map(_ + ".exe")) {
val path = build_dir + Path.basic(name)
if (path.is_file) Isabelle_System.copy_file(path, platform_dir)
}
/* settings */
val etc_dir = Isabelle_System.make_directory(component_dir + Path.basic("etc"))
File.write(etc_dir + Path.basic("settings"),
"""# -*- shell-script -*- :mode=shellscript:
SPASS_HOME="$COMPONENT/$ISABELLE_PLATFORM64"
SPASS_VERSION=""" + quote(version) + """
""")
/* README */
File.write(component_dir + Path.basic("README"),
"""This distribution of SPASS 3.8ds, described in Blanchette, Popescu, Wand, and
Weidenbach's ITP 2012 paper "More SPASS with Isabelle", has been compiled from
sources available at """ + download_url + """
via "make".
The Windows/Cygwin compilation required commenting out the line
#include "execinfo.h"
in "misc.c" as well as most of the body of the "misc_DumpCore" function.
The latest official SPASS sources can be downloaded from
http://www.spass-prover.org/. Be aware, however, that the official SPASS
releases are not compatible with Isabelle.
Viel SPASS!
Jasmin Blanchette
16-May-2018
Makarius
""" + Date.Format.date(Date.now()) + "\n")
})
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_spass", "build prover component from source distribution",
Scala_Project.here, args =>
{
var target_dir = Path.current
var download_url = default_download_url
var verbose = false
val getopts = Getopts("""
Usage: isabelle build_spass [OPTIONS]
Options are:
-D DIR target directory (default ".")
-U URL download URL
(default: """" + default_download_url + """")
-v verbose
Build prover component from the specified source distribution.
""",
"D:" -> (arg => target_dir = Path.explode(arg)),
"U:" -> (arg => download_url = arg),
"v" -> (_ => verbose = true))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val progress = new Console_Progress()
build_spass(download_url = download_url, verbose = verbose, progress = progress,
target_dir = target_dir)
})
}
diff --git a/src/Pure/Admin/build_sqlite.scala b/src/Pure/Admin/build_sqlite.scala
--- a/src/Pure/Admin/build_sqlite.scala
+++ b/src/Pure/Admin/build_sqlite.scala
@@ -1,115 +1,115 @@
/* Title: Pure/Admin/build_sqlite.scala
Author: Makarius
Build Isabelle sqlite-jdbc component from official download.
*/
package isabelle
object Build_SQLite
{
/* build sqlite */
def build_sqlite(
download_url: String,
progress: Progress = new Progress,
- target_dir: Path = Path.current)
+ target_dir: Path = Path.current): Unit =
{
val Download_Name = """^.*/([^/]+)\.jar""".r
val download_name =
download_url match {
case Download_Name(download_name) => download_name
case _ => error("Malformed jar download URL: " + quote(download_url))
}
/* component */
val component_dir = Isabelle_System.new_directory(target_dir + Path.basic(download_name))
progress.echo("Component " + component_dir)
/* README */
File.write(component_dir + Path.basic("README"),
"This is " + download_name + " from\n" + download_url +
"\n\n Makarius\n " + Date.Format.date(Date.now()) + "\n")
/* settings */
val etc_dir = Isabelle_System.make_directory(component_dir + Path.basic("etc"))
File.write(etc_dir + Path.basic("settings"),
"""# -*- shell-script -*- :mode=shellscript:
ISABELLE_SQLITE_HOME="$COMPONENT"
classpath "$ISABELLE_SQLITE_HOME/""" + download_name + """.jar"
""")
/* jar */
val jar = component_dir + Path.basic(download_name).ext("jar")
Isabelle_System.download(download_url, jar, progress = progress)
Isabelle_System.with_tmp_dir("sqlite")(jar_dir =>
{
progress.echo("Unpacking " + jar)
Isabelle_System.bash("isabelle_jdk jar xf " + File.bash_path(jar.absolute),
cwd = jar_dir.file).check
val jar_files =
List(
"META-INF/maven/org.xerial/sqlite-jdbc/LICENSE" -> ".",
"META-INF/maven/org.xerial/sqlite-jdbc/LICENSE.zentus" -> ".",
"org/sqlite/native/Linux/aarch64/libsqlitejdbc.so" -> "arm64-linux",
"org/sqlite/native/Linux/x86_64/libsqlitejdbc.so" -> "x86_64-linux",
"org/sqlite/native/Mac/aarch64/libsqlitejdbc.jnilib" -> "arm64-darwin",
"org/sqlite/native/Mac/x86_64/libsqlitejdbc.jnilib" -> "x86_64-darwin",
"org/sqlite/native/Windows/x86_64/sqlitejdbc.dll" -> "x86_64-windows")
for ((file, dir) <- jar_files) {
val target = Isabelle_System.make_directory(component_dir + Path.explode(dir))
Isabelle_System.copy_file(jar_dir + Path.explode(file), target)
}
File.set_executable(component_dir + Path.explode("x86_64-windows/sqlitejdbc.dll"), true)
})
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_sqlite", "build Isabelle sqlite-jdbc component from official download",
Scala_Project.here, args =>
{
var target_dir = Path.current
val getopts = Getopts("""
Usage: isabelle build_sqlite [OPTIONS] DOWNLOAD
Options are:
-D DIR target directory (default ".")
Build sqlite-jdbc component from the specified download URL (JAR), see also
https://github.com/xerial/sqlite-jdbc and
https://oss.sonatype.org/content/repositories/releases/org/xerial/sqlite-jdbc
""",
"D:" -> (arg => target_dir = Path.explode(arg)))
val more_args = getopts(args)
val download_url =
more_args match {
case List(download_url) => download_url
case _ => getopts.usage()
}
val progress = new Console_Progress()
build_sqlite(download_url, progress = progress, target_dir = target_dir)
})
}
diff --git a/src/Pure/Admin/build_status.scala b/src/Pure/Admin/build_status.scala
--- a/src/Pure/Admin/build_status.scala
+++ b/src/Pure/Admin/build_status.scala
@@ -1,621 +1,621 @@
/* Title: Pure/Admin/build_status.scala
Author: Makarius
Present recent build status information from database.
*/
package isabelle
object Build_Status
{
/* defaults */
val default_target_dir = Path.explode("build_status")
val default_image_size = (800, 600)
val default_history = 30
def default_profiles: List[Profile] =
Jenkins.build_status_profiles ::: Isabelle_Cronjob.build_status_profiles
/* data profiles */
sealed case class Profile(
description: String, history: Int = 0, afp: Boolean = false, bulky: Boolean = false, sql: String)
{
def days(options: Options): Int = options.int("build_log_history") max history
def stretch(options: Options): Double =
(days(options) max default_history min (default_history * 5)).toDouble / default_history
def select(options: Options, columns: List[SQL.Column], only_sessions: Set[String]): SQL.Source =
{
Build_Log.Data.universal_table.select(columns, distinct = true,
sql = "WHERE " +
Build_Log.Data.pull_date(afp) + " > " + Build_Log.Data.recent_time(days(options)) +
" AND " +
SQL.member(Build_Log.Data.status.ident,
List(
Build_Log.Session_Status.finished.toString,
Build_Log.Session_Status.failed.toString)) +
(if (only_sessions.isEmpty) ""
else " AND " + SQL.member(Build_Log.Data.session_name.ident, only_sessions)) +
" AND " + SQL.enclose(sql))
}
}
/* build status */
def build_status(options: Options,
progress: Progress = new Progress,
profiles: List[Profile] = default_profiles,
only_sessions: Set[String] = Set.empty,
verbose: Boolean = false,
target_dir: Path = default_target_dir,
ml_statistics: Boolean = false,
- image_size: (Int, Int) = default_image_size)
+ image_size: (Int, Int) = default_image_size): Unit =
{
val ml_statistics_domain =
Iterator(ML_Statistics.heap_fields, ML_Statistics.program_fields, ML_Statistics.tasks_fields,
ML_Statistics.workers_fields).flatMap(_._2).toSet
val data =
read_data(options, progress = progress, profiles = profiles,
only_sessions = only_sessions, verbose = verbose,
ml_statistics = ml_statistics, ml_statistics_domain = ml_statistics_domain)
present_data(data, progress = progress, target_dir = target_dir, image_size = image_size)
}
/* read data */
sealed case class Data(date: Date, entries: List[Data_Entry])
sealed case class Data_Entry(
name: String, hosts: List[String], stretch: Double, sessions: List[Session])
{
def failed_sessions: List[Session] =
sessions.filter(_.head.failed).sortBy(_.name)
}
sealed case class Session(
name: String, threads: Int, entries: List[Entry],
ml_statistics: ML_Statistics, ml_statistics_date: Long)
{
require(entries.nonEmpty, "no entries")
lazy val sorted_entries: List[Entry] = entries.sortBy(entry => - entry.date)
def head: Entry = sorted_entries.head
def order: Long = - head.timing.elapsed.ms
def finished_entries: List[Entry] = sorted_entries.filter(_.finished)
def finished_entries_size: Int = finished_entries.map(_.date).toSet.size
def check_timing: Boolean = finished_entries_size >= 3
def check_heap: Boolean =
finished_entries_size >= 3 &&
finished_entries.forall(entry =>
entry.maximum_heap > 0 ||
entry.average_heap > 0 ||
entry.stored_heap > 0)
def make_csv: CSV.File =
{
val header =
List("session_name",
"chapter",
"pull_date",
"afp_pull_date",
"isabelle_version",
"afp_version",
"timing_elapsed",
"timing_cpu",
"timing_gc",
"ml_timing_elapsed",
"ml_timing_cpu",
"ml_timing_gc",
"maximum_code",
"average_code",
"maximum_stack",
"average_stack",
"maximum_heap",
"average_heap",
"stored_heap",
"status")
val date_format = Date.Format("uuuu-MM-dd HH:mm:ss")
val records =
for (entry <- sorted_entries) yield {
CSV.Record(name,
entry.chapter,
date_format(entry.pull_date),
entry.afp_pull_date match { case Some(date) => date_format(date) case None => "" },
entry.isabelle_version,
entry.afp_version,
entry.timing.elapsed.ms,
entry.timing.cpu.ms,
entry.timing.gc.ms,
entry.ml_timing.elapsed.ms,
entry.ml_timing.cpu.ms,
entry.ml_timing.gc.ms,
entry.maximum_code,
entry.average_code,
entry.maximum_stack,
entry.average_stack,
entry.maximum_heap,
entry.average_heap,
entry.stored_heap,
entry.status)
}
CSV.File(name, header, records)
}
}
sealed case class Entry(
chapter: String,
pull_date: Date,
afp_pull_date: Option[Date],
isabelle_version: String,
afp_version: String,
timing: Timing,
ml_timing: Timing,
maximum_code: Long,
average_code: Long,
maximum_stack: Long,
average_stack: Long,
maximum_heap: Long,
average_heap: Long,
stored_heap: Long,
status: Build_Log.Session_Status.Value,
errors: List[String])
{
val date: Long = (afp_pull_date getOrElse pull_date).unix_epoch
def finished: Boolean = status == Build_Log.Session_Status.finished
def failed: Boolean = status == Build_Log.Session_Status.failed
def present_errors(name: String): XML.Body =
{
if (errors.isEmpty)
HTML.text(name + print_version(isabelle_version, afp_version, chapter))
else {
HTML.tooltip_errors(HTML.text(name), errors.map(s => HTML.text(Symbol.decode(s)))) ::
HTML.text(print_version(isabelle_version, afp_version, chapter))
}
}
}
sealed case class Image(name: String, width: Int, height: Int)
{
def path: Path = Path.basic(name)
}
def print_version(
isabelle_version: String, afp_version: String = "", chapter: String = AFP.chapter): String =
{
val body =
proper_string(isabelle_version).map("Isabelle/" + _).toList :::
(if (chapter == AFP.chapter) proper_string(afp_version).map("AFP/" + _) else None).toList
if (body.isEmpty) "" else body.mkString(" (", ", ", ")")
}
def read_data(options: Options,
progress: Progress = new Progress,
profiles: List[Profile] = default_profiles,
only_sessions: Set[String] = Set.empty,
ml_statistics: Boolean = false,
ml_statistics_domain: String => Boolean = (key: String) => true,
verbose: Boolean = false): Data =
{
val date = Date.now()
var data_hosts = Map.empty[String, Set[String]]
var data_stretch = Map.empty[String, Double]
var data_entries = Map.empty[String, Map[String, Session]]
def get_hosts(data_name: String): Set[String] =
data_hosts.getOrElse(data_name, Set.empty)
val store = Build_Log.store(options)
using(store.open_database())(db =>
{
for (profile <- profiles.sortBy(_.description)) {
progress.echo("input " + quote(profile.description))
val afp = profile.afp
val columns =
List(
Build_Log.Data.pull_date(afp = false),
Build_Log.Data.pull_date(afp = true),
Build_Log.Prop.build_host,
Build_Log.Prop.isabelle_version,
Build_Log.Prop.afp_version,
Build_Log.Settings.ISABELLE_BUILD_OPTIONS,
Build_Log.Settings.ML_PLATFORM,
Build_Log.Data.session_name,
Build_Log.Data.chapter,
Build_Log.Data.groups,
Build_Log.Data.threads,
Build_Log.Data.timing_elapsed,
Build_Log.Data.timing_cpu,
Build_Log.Data.timing_gc,
Build_Log.Data.ml_timing_elapsed,
Build_Log.Data.ml_timing_cpu,
Build_Log.Data.ml_timing_gc,
Build_Log.Data.heap_size,
Build_Log.Data.status,
Build_Log.Data.errors) :::
(if (ml_statistics) List(Build_Log.Data.ml_statistics) else Nil)
val Threads_Option = """threads\s*=\s*(\d+)""".r
val sql = profile.select(options, columns, only_sessions)
progress.echo_if(verbose, sql)
db.using_statement(sql)(stmt =>
{
val res = stmt.execute_query()
while (res.next()) {
val session_name = res.string(Build_Log.Data.session_name)
val chapter = res.string(Build_Log.Data.chapter)
val groups = split_lines(res.string(Build_Log.Data.groups))
val threads =
{
val threads1 =
res.string(Build_Log.Settings.ISABELLE_BUILD_OPTIONS) match {
case Threads_Option(Value.Int(i)) => i
case _ => 1
}
val threads2 = res.get_int(Build_Log.Data.threads).getOrElse(1)
threads1 max threads2
}
val ml_platform = res.string(Build_Log.Settings.ML_PLATFORM)
val data_name =
profile.description +
(if (ml_platform.startsWith("x86_64-")) ", 64bit" else "") +
(if (threads == 1) "" else ", " + threads + " threads")
res.get_string(Build_Log.Prop.build_host).foreach(host =>
data_hosts += (data_name -> (get_hosts(data_name) + host)))
data_stretch += (data_name -> profile.stretch(options))
val isabelle_version = res.string(Build_Log.Prop.isabelle_version)
val afp_version = res.string(Build_Log.Prop.afp_version)
val ml_stats =
ML_Statistics(
if (ml_statistics) {
Properties.uncompress(res.bytes(Build_Log.Data.ml_statistics), cache = store.cache)
}
else Nil,
domain = ml_statistics_domain,
heading = session_name + print_version(isabelle_version, afp_version, chapter))
val entry =
Entry(
chapter = chapter,
pull_date = res.date(Build_Log.Data.pull_date(afp = false)),
afp_pull_date =
if (afp) res.get_date(Build_Log.Data.pull_date(afp = true)) else None,
isabelle_version = isabelle_version,
afp_version = afp_version,
timing =
res.timing(
Build_Log.Data.timing_elapsed,
Build_Log.Data.timing_cpu,
Build_Log.Data.timing_gc),
ml_timing =
res.timing(
Build_Log.Data.ml_timing_elapsed,
Build_Log.Data.ml_timing_cpu,
Build_Log.Data.ml_timing_gc),
maximum_code = ml_stats.maximum(ML_Statistics.CODE_SIZE).toLong,
average_code = ml_stats.average(ML_Statistics.CODE_SIZE).toLong,
maximum_stack = ml_stats.maximum(ML_Statistics.STACK_SIZE).toLong,
average_stack = ml_stats.average(ML_Statistics.STACK_SIZE).toLong,
maximum_heap = ml_stats.maximum(ML_Statistics.HEAP_SIZE).toLong,
average_heap = ml_stats.average(ML_Statistics.HEAP_SIZE).toLong,
stored_heap = ML_Statistics.mem_scale(res.long(Build_Log.Data.heap_size)),
status = Build_Log.Session_Status.withName(res.string(Build_Log.Data.status)),
errors =
Build_Log.uncompress_errors(
res.bytes(Build_Log.Data.errors), cache = store.cache))
val sessions = data_entries.getOrElse(data_name, Map.empty)
val session =
sessions.get(session_name) match {
case None =>
Session(session_name, threads, List(entry), ml_stats, entry.date)
case Some(old) =>
val (ml_stats1, ml_stats1_date) =
if (entry.date > old.ml_statistics_date) (ml_stats, entry.date)
else (old.ml_statistics, old.ml_statistics_date)
Session(session_name, threads, entry :: old.entries, ml_stats1, ml_stats1_date)
}
if ((!afp || chapter == AFP.chapter) &&
(!profile.bulky || groups.exists(AFP.groups_bulky.toSet))) {
data_entries += (data_name -> (sessions + (session_name -> session)))
}
}
})
}
})
val sorted_entries =
(for {
(name, sessions) <- data_entries.toList
sorted_sessions <- proper_list(sessions.toList.map(_._2).sortBy(_.order))
}
yield {
val hosts = get_hosts(name).toList.sorted
val stretch = data_stretch(name)
Data_Entry(name, hosts, stretch, sorted_sessions)
}).sortBy(_.name)
Data(date, sorted_entries)
}
/* present data */
def present_data(data: Data,
progress: Progress = new Progress,
target_dir: Path = default_target_dir,
- image_size: (Int, Int) = default_image_size)
+ image_size: (Int, Int) = default_image_size): Unit =
{
def clean_name(name: String): String =
name.flatMap(c => if (c == ' ' || c == '/') "_" else if (c == ',') "" else c.toString)
HTML.write_document(target_dir, "index.html",
List(HTML.title("Isabelle build status")),
List(HTML.chapter("Isabelle build status"),
HTML.par(
List(HTML.description(
List(HTML.text("status date:") -> HTML.text(data.date.toString))))),
HTML.par(
List(HTML.itemize(data.entries.map({ case data_entry =>
List(
HTML.link(clean_name(data_entry.name) + "/index.html",
HTML.text(data_entry.name))) :::
(data_entry.failed_sessions match {
case Nil => Nil
case sessions =>
HTML.break :::
List(HTML.span(HTML.error_message, HTML.text("Failed sessions:"))) :::
List(HTML.itemize(sessions.map(s => s.head.present_errors(s.name))))
})
}))))))
for (data_entry <- data.entries) {
val data_name = data_entry.name
val (image_width, image_height) = image_size
val image_width_stretch = (image_width * data_entry.stretch).toInt
progress.echo("output " + quote(data_name))
val dir = Isabelle_System.make_directory(target_dir + Path.basic(clean_name(data_name)))
val data_files =
(for (session <- data_entry.sessions) yield {
val csv_file = session.make_csv
csv_file.write(dir)
session.name -> csv_file
}).toMap
val session_plots =
Par_List.map((session: Session) =>
Isabelle_System.with_tmp_file(session.name, "data") { data_file =>
Isabelle_System.with_tmp_file(session.name, "gnuplot") { gnuplot_file =>
def plot_name(kind: String): String = session.name + "_" + kind + ".png"
File.write(data_file,
cat_lines(
session.finished_entries.map(entry =>
List(entry.date,
entry.timing.elapsed.minutes,
entry.timing.resources.minutes,
entry.ml_timing.elapsed.minutes,
entry.ml_timing.resources.minutes,
entry.maximum_code,
entry.maximum_code,
entry.average_stack,
entry.maximum_stack,
entry.average_heap,
entry.average_heap,
entry.stored_heap).mkString(" "))))
val max_time =
((0.0 /: session.finished_entries){ case (m, entry) =>
m.max(entry.timing.elapsed.minutes).
max(entry.timing.resources.minutes).
max(entry.ml_timing.elapsed.minutes).
max(entry.ml_timing.resources.minutes) } max 0.1) * 1.1
val timing_range = "[0:" + max_time + "]"
def gnuplot(plot_name: String, plots: List[String], range: String): Image =
{
val image = Image(plot_name, image_width_stretch, image_height)
File.write(gnuplot_file, """
set terminal png size """ + image.width + "," + image.height + """
set output """ + quote(File.standard_path(dir + image.path)) + """
set xdata time
set timefmt "%s"
set format x "%d-%b"
set xlabel """ + quote(session.name) + """ noenhanced
set key left bottom
plot [] """ + range + " " +
plots.map(s => quote(data_file.implode) + " " + s).mkString(", ") + "\n")
val result =
Isabelle_System.bash("\"$ISABELLE_GNUPLOT\" " + File.bash_path(gnuplot_file))
if (!result.ok)
result.error("Gnuplot failed for " + data_name + "/" + plot_name).check
image
}
val timing_plots =
{
val plots1 =
List(
""" using 1:2 smooth sbezier title "elapsed time (smooth)" """,
""" using 1:2 smooth csplines title "elapsed time" """)
val plots2 =
List(
""" using 1:3 smooth sbezier title "cpu time (smooth)" """,
""" using 1:3 smooth csplines title "cpu time" """)
if (session.threads == 1) plots1 else plots1 ::: plots2
}
val ml_timing_plots =
List(
""" using 1:4 smooth sbezier title "ML elapsed time (smooth)" """,
""" using 1:4 smooth csplines title "ML elapsed time" """,
""" using 1:5 smooth sbezier title "ML cpu time (smooth)" """,
""" using 1:5 smooth csplines title "ML cpu time" """)
val heap_plots =
List(
""" using 1:10 smooth sbezier title "heap maximum (smooth)" """,
""" using 1:10 smooth csplines title "heap maximum" """,
""" using 1:11 smooth sbezier title "heap average (smooth)" """,
""" using 1:11 smooth csplines title "heap average" """,
""" using 1:12 smooth sbezier title "heap stored (smooth)" """,
""" using 1:12 smooth csplines title "heap stored" """)
def jfreechart(plot_name: String, fields: ML_Statistics.Fields): Image =
{
val image = Image(plot_name, image_width, image_height)
val chart =
session.ml_statistics.chart(
fields._1 + ": " + session.ml_statistics.heading, fields._2)
Graphics_File.write_chart_png(
(dir + image.path).file, chart, image.width, image.height)
image
}
val images =
(if (session.check_timing)
List(
gnuplot(plot_name("timing"), timing_plots, timing_range),
gnuplot(plot_name("ml_timing"), ml_timing_plots, timing_range))
else Nil) :::
(if (session.check_heap)
List(gnuplot(plot_name("heap"), heap_plots, "[0:]"))
else Nil) :::
(if (session.ml_statistics.content.nonEmpty)
List(jfreechart(plot_name("heap_chart"), ML_Statistics.heap_fields),
jfreechart(plot_name("program_chart"), ML_Statistics.program_fields)) :::
(if (session.threads > 1)
List(
jfreechart(plot_name("tasks_chart"), ML_Statistics.tasks_fields),
jfreechart(plot_name("workers_chart"), ML_Statistics.workers_fields))
else Nil)
else Nil)
session.name -> images
}
}, data_entry.sessions).toMap
HTML.write_document(dir, "index.html",
List(HTML.title("Isabelle build status for " + data_name)),
HTML.chapter("Isabelle build status for " + data_name) ::
HTML.par(
List(HTML.description(
List(
HTML.text("status date:") -> HTML.text(data.date.toString),
HTML.text("build host:") -> HTML.text(commas(data_entry.hosts)))))) ::
HTML.par(
List(HTML.itemize(
data_entry.sessions.map(session =>
HTML.link("#session_" + session.name, HTML.text(session.name)) ::
HTML.text(" (" + session.head.timing.message_resources + ")"))))) ::
data_entry.sessions.flatMap(session =>
List(
HTML.section(HTML.id("session_" + session.name), session.name),
HTML.par(
HTML.description(
List(
HTML.text("data:") ->
List(HTML.link(data_files(session.name).file_name, HTML.text("CSV"))),
HTML.text("timing:") -> HTML.text(session.head.timing.message_resources),
HTML.text("ML timing:") -> HTML.text(session.head.ml_timing.message_resources)) :::
ML_Statistics.mem_print(session.head.maximum_code).map(s =>
HTML.text("code maximum:") -> HTML.text(s)).toList :::
ML_Statistics.mem_print(session.head.average_code).map(s =>
HTML.text("code average:") -> HTML.text(s)).toList :::
ML_Statistics.mem_print(session.head.maximum_stack).map(s =>
HTML.text("stack maximum:") -> HTML.text(s)).toList :::
ML_Statistics.mem_print(session.head.average_stack).map(s =>
HTML.text("stack average:") -> HTML.text(s)).toList :::
ML_Statistics.mem_print(session.head.maximum_heap).map(s =>
HTML.text("heap maximum:") -> HTML.text(s)).toList :::
ML_Statistics.mem_print(session.head.average_heap).map(s =>
HTML.text("heap average:") -> HTML.text(s)).toList :::
ML_Statistics.mem_print(session.head.stored_heap).map(s =>
HTML.text("heap stored:") -> HTML.text(s)).toList :::
proper_string(session.head.isabelle_version).map(s =>
HTML.text("Isabelle version:") -> HTML.text(s)).toList :::
proper_string(session.head.afp_version).map(s =>
HTML.text("AFP version:") -> HTML.text(s)).toList) ::
session_plots.getOrElse(session.name, Nil).map(image =>
HTML.size(image.width / 2, image.height / 2)(HTML.image(image.name)))))))
}
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_status", "present recent build status information from database",
Scala_Project.here, args =>
{
var target_dir = default_target_dir
var ml_statistics = false
var only_sessions = Set.empty[String]
var options = Options.init()
var image_size = default_image_size
var verbose = false
val getopts = Getopts("""
Usage: isabelle build_status [OPTIONS]
Options are:
-D DIR target directory (default """ + default_target_dir + """)
-M include full ML statistics
-S SESSIONS only given SESSIONS (comma separated)
-l DAYS length of relevant history (default """ + options.int("build_log_history") + """)
-o OPTION override Isabelle system OPTION (via NAME=VAL or NAME)
-s WxH size of PNG image (default """ + image_size._1 + "x" + image_size._2 + """)
-v verbose
Present performance statistics from build log database, which is specified
via system options build_log_database_host, build_log_database_user,
build_log_history etc.
""",
"D:" -> (arg => target_dir = Path.explode(arg)),
"M" -> (_ => ml_statistics = true),
"S:" -> (arg => only_sessions = space_explode(',', arg).toSet),
"l:" -> (arg => options = options + ("build_log_history=" + arg)),
"o:" -> (arg => options = options + arg),
"s:" -> (arg =>
space_explode('x', arg).map(Value.Int.parse(_)) match {
case List(w, h) if w > 0 && h > 0 => image_size = (w, h)
case _ => error("Error bad PNG image size: " + quote(arg))
}),
"v" -> (_ => verbose = true))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val progress = new Console_Progress
build_status(options, progress = progress, only_sessions = only_sessions, verbose = verbose,
target_dir = target_dir, ml_statistics = ml_statistics, image_size = image_size)
})
}
diff --git a/src/Pure/Admin/build_vampire.scala b/src/Pure/Admin/build_vampire.scala
--- a/src/Pure/Admin/build_vampire.scala
+++ b/src/Pure/Admin/build_vampire.scala
@@ -1,171 +1,171 @@
/* Title: Pure/Admin/build_vampire.scala
Author: Makarius
Build Isabelle Vampire component from repository.
*/
package isabelle
object Build_Vampire
{
val default_repository = "https://github.com/vprover/vampire.git"
val default_version1 = "4.5.1"
val default_version2 = "df87588848db"
val default_jobs = 1
def make_component_name(version: String) = "vampire-" + version
/* build Vampire */
def build_vampire(
repository: String = default_repository,
version1: String = default_version1,
version2: String = default_version2,
jobs: Int = default_jobs,
component_name: String = "",
verbose: Boolean = false,
progress: Progress = new Progress,
- target_dir: Path = Path.current)
+ target_dir: Path = Path.current): Unit =
{
Isabelle_System.require_command("git", "cmake")
Isabelle_System.with_tmp_dir("build")(tmp_dir =>
{
/* component and platform */
val component = proper_string(component_name) getOrElse make_component_name(version1)
val component_dir = Isabelle_System.new_directory(target_dir + Path.basic(component))
progress.echo("Component " + component_dir)
val platform_name =
proper_string(Isabelle_System.getenv("ISABELLE_PLATFORM64")) getOrElse
error("No 64bit platform")
val platform_dir = Isabelle_System.make_directory(component_dir + Path.basic(platform_name))
/* clone repository */
progress.echo("Cloning repository " + repository)
progress.bash("git clone " + Bash.string(repository) + " vampire",
cwd = tmp_dir.file, echo = verbose).check
val source_dir = tmp_dir + Path.explode("vampire")
Isabelle_System.copy_file(source_dir + Path.explode("LICENCE"), component_dir)
/* build versions */
for { (rev, exe) <- List(version1 -> "vampire", version2 -> "vampire_polymorphic") } {
progress.echo("Building " + exe + " (rev " + rev + ")")
progress.bash("git checkout --quiet --detach " + Bash.string(rev),
cwd = source_dir.file, echo = verbose).check
val build_dir = source_dir + Path.explode("build")
Isabelle_System.rm_tree(build_dir)
Isabelle_System.make_directory(build_dir)
val cmake_opts = if (Platform.is_linux) "-DBUILD_SHARED_LIBS=0 " else ""
val cmake_out =
progress.bash("cmake " + cmake_opts + """-G "Unix Makefiles" ..""",
cwd = build_dir.file, echo = verbose).check.out
val Pattern = """-- Setting binary name to '?([^\s']*)'?""".r
val binary =
split_lines(cmake_out).collectFirst({ case Pattern(name) => name })
.getOrElse(error("Failed to determine binary name from cmake output:\n" + cmake_out))
progress.bash("make -j" + jobs, cwd = build_dir.file, echo = verbose).check
Isabelle_System.copy_file(build_dir + Path.basic("bin") + Path.basic(binary).platform_exe,
platform_dir + Path.basic(exe).platform_exe)
}
/* settings */
val etc_dir = Isabelle_System.make_directory(component_dir + Path.basic("etc"))
File.write(etc_dir + Path.basic("settings"),
"""# -*- shell-script -*- :mode=shellscript:
VAMPIRE_HOME="$COMPONENT/$ISABELLE_PLATFORM64"
ISABELLE_VAMPIRE="$VAMPIRE_HOME/vampire"
ISABELLE_VAMPIRE_POLYMORPHIC="$VAMPIRE_HOME/vampire_polymorphic"
VAMPIRE_EXTRA_OPTIONS=""
""")
/* README */
File.write(component_dir + Path.basic("README"),
"This Isabelle component provides two versions of Vampire from\n" + repository + """
* vampire: standard version (regular stable release)
* vampire_polymorphic: special version for polymorphic FOL and HOL
(intermediate repository version)
The executables have been built like this:
git checkout COMMIT
cmake .
make
The precise commit id is revealed by executing "vampire --version".
Makarius
""" + Date.Format.date(Date.now()) + "\n")
})
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_vampire", "build prover component from repository", Scala_Project.here,
args =>
{
var target_dir = Path.current
var repository = default_repository
var version1 = default_version1
var version2 = default_version2
var jobs = default_jobs
var component_name = ""
var verbose = false
val getopts = Getopts("""
Usage: isabelle build_vampire [OPTIONS]
Options are:
-D DIR target directory (default ".")
-U URL repository (default: """" + default_repository + """")
-V REV1 standard version (default: """" + default_version1 + """")
-W REV2 polymorphic version (default: """" + default_version2 + """")
-j NUMBER parallel jobs for make (default: """ + default_jobs + """)
-n NAME component name (default: """" + make_component_name("REV1") + """")
-v verbose
Build prover component from official download.
""",
"D:" -> (arg => target_dir = Path.explode(arg)),
"U:" -> (arg => repository = arg),
"V:" -> (arg => version1 = arg),
"W:" -> (arg => version2 = arg),
"j:" -> (arg => jobs = Value.Nat.parse(arg)),
"n:" -> (arg => component_name = arg),
"v" -> (_ => verbose = true))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val progress = new Console_Progress()
build_vampire(repository = repository, version1 = version1, version2 = version2,
component_name = component_name, jobs = jobs, verbose = verbose, progress = progress,
target_dir = target_dir)
})
}
diff --git a/src/Pure/Admin/build_verit.scala b/src/Pure/Admin/build_verit.scala
--- a/src/Pure/Admin/build_verit.scala
+++ b/src/Pure/Admin/build_verit.scala
@@ -1,159 +1,159 @@
/* Title: Pure/Admin/build_csdp.scala
Author: Makarius
Build Isabelle veriT component from official download.
*/
package isabelle
object Build_VeriT
{
val default_download_url = "https://verit.loria.fr/rmx/2020.10/verit-2020.10-rmx.tar.gz"
/* build veriT */
def build_verit(
download_url: String = default_download_url,
verbose: Boolean = false,
progress: Progress = new Progress,
target_dir: Path = Path.current,
- mingw: MinGW = MinGW.none)
+ mingw: MinGW = MinGW.none): Unit =
{
mingw.check
Isabelle_System.with_tmp_dir("build")(tmp_dir =>
{
/* component */
val Archive_Name = """^.*?([^/]+)$""".r
val Version = """^[^-]+-(.+)\.tar.gz$""".r
val archive_name =
download_url match {
case Archive_Name(name) => name
case _ => error("Failed to determine source archive name from " + quote(download_url))
}
val version =
archive_name match {
case Version(version) => version
case _ => error("Failed to determine component version from " + quote(archive_name))
}
val component_name = "verit-" + version
val component_dir = Isabelle_System.new_directory(target_dir + Path.basic(component_name))
progress.echo("Component " + component_dir)
/* platform */
val platform_name =
proper_string(Isabelle_System.getenv("ISABELLE_WINDOWS_PLATFORM64")) orElse
proper_string(Isabelle_System.getenv("ISABELLE_PLATFORM64")) getOrElse
error("No 64bit platform")
val platform_dir = Isabelle_System.make_directory(component_dir + Path.basic(platform_name))
/* download source */
val archive_path = tmp_dir + Path.basic(archive_name)
Isabelle_System.download(download_url, archive_path, progress = progress)
Isabelle_System.bash("tar xzf " + File.bash_path(archive_path), cwd = tmp_dir.file).check
val source_name = File.get_dir(tmp_dir)
Isabelle_System.bash(
"tar xzf " + archive_path + " && mv " + Bash.string(source_name) + " src",
cwd = component_dir.file).check
/* build */
progress.echo("Building veriT for " + platform_name + " ...")
val configure_options =
if (Platform.is_linux) "LDFLAGS=-Wl,-rpath,_DUMMY_" else ""
val build_dir = tmp_dir + Path.basic(source_name)
progress.bash(mingw.bash_script("set -e\n./configure " + configure_options + "\nmake"),
cwd = build_dir.file, echo = verbose).check
/* install */
Isabelle_System.copy_file(build_dir + Path.explode("LICENSE"), component_dir)
val exe_path = Path.basic("veriT").platform_exe
Isabelle_System.copy_file(build_dir + exe_path, platform_dir)
Executable.libraries_closure(platform_dir + exe_path, filter = Set("libgmp"), mingw = mingw)
/* settings */
val etc_dir = Isabelle_System.make_directory(component_dir + Path.basic("etc"))
File.write(etc_dir + Path.basic("settings"),
"""# -*- shell-script -*- :mode=shellscript:
ISABELLE_VERIT="$COMPONENT/${ISABELLE_WINDOWS_PLATFORM64:-$ISABELLE_PLATFORM64}/veriT"
""")
/* README */
File.write(component_dir + Path.basic("README"),
"""This is veriT """ + version + """ from
""" + download_url + """
It has been built from sources like this:
cd src
./configure
make
Makarius
""" + Date.Format.date(Date.now()) + "\n")
})
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_verit", "build prover component from official download",
Scala_Project.here, args =>
{
var target_dir = Path.current
var mingw = MinGW.none
var download_url = default_download_url
var verbose = false
val getopts = Getopts("""
Usage: isabelle build_verit [OPTIONS]
Options are:
-D DIR target directory (default ".")
-M DIR msys/mingw root specification for Windows
-U URL download URL
(default: """" + default_download_url + """")
-v verbose
Build prover component from official download.
""",
"D:" -> (arg => target_dir = Path.explode(arg)),
"M:" -> (arg => mingw = MinGW(Path.explode(arg))),
"U:" -> (arg => download_url = arg),
"v" -> (_ => verbose = true))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val progress = new Console_Progress()
build_verit(download_url = download_url, verbose = verbose, progress = progress,
target_dir = target_dir, mingw = mingw)
})
}
diff --git a/src/Pure/Admin/build_zipperposition.scala b/src/Pure/Admin/build_zipperposition.scala
--- a/src/Pure/Admin/build_zipperposition.scala
+++ b/src/Pure/Admin/build_zipperposition.scala
@@ -1,124 +1,124 @@
/* Title: Pure/Admin/build_zipperposition.scala
Author: Makarius
Build Isabelle Zipperposition component from OPAM repository.
*/
package isabelle
object Build_Zipperposition
{
val default_version = "2.0"
/* build Zipperposition */
def build_zipperposition(
version: String = default_version,
verbose: Boolean = false,
progress: Progress = new Progress,
- target_dir: Path = Path.current)
+ target_dir: Path = Path.current): Unit =
{
Isabelle_System.with_tmp_dir("build")(build_dir =>
{
if (!Platform.is_windows) Isabelle_System.require_command("patchelf")
/* component */
val component_name = "zipperposition-" + version
val component_dir = Isabelle_System.new_directory(target_dir + Path.basic(component_name))
progress.echo("Component " + component_dir)
/* platform */
val platform_name =
proper_string(Isabelle_System.getenv("ISABELLE_PLATFORM64")) getOrElse
error("No 64bit platform")
val platform_dir = Isabelle_System.make_directory(component_dir + Path.basic(platform_name))
/* build */
progress.echo("OCaml/OPAM setup ...")
progress.bash("isabelle ocaml_setup", echo = verbose).check
progress.echo("Building Zipperposition for " + platform_name + " ...")
progress.bash(cwd = build_dir.file, echo = verbose,
script = "isabelle_opam install -y --destdir=" + File.bash_path(build_dir) +
" zipperposition=" + Bash.string(version)).check
/* install */
Isabelle_System.copy_file(build_dir + Path.explode("doc/zipperposition/LICENSE"),
component_dir)
val prg_path = Path.basic("zipperposition")
val exe_path = prg_path.platform_exe
Isabelle_System.copy_file(build_dir + Path.basic("bin") + prg_path, platform_dir + exe_path)
if (!Platform.is_windows) {
Executable.libraries_closure(
platform_dir + exe_path, filter = Set("libgmp"), patchelf = true)
}
/* settings */
val etc_dir = Isabelle_System.make_directory(component_dir + Path.basic("etc"))
File.write(etc_dir + Path.basic("settings"),
"""# -*- shell-script -*- :mode=shellscript:
ZIPPERPOSITION_HOME="$COMPONENT/$ISABELLE_PLATFORM64"
""")
/* README */
File.write(component_dir + Path.basic("README"),
"""This is Zipperposition """ + version + """ from the OCaml/OPAM repository.
Makarius
""" + Date.Format.date(Date.now()) + "\n")
})
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("build_zipperposition", "build prover component from OPAM repository",
Scala_Project.here, args =>
{
var target_dir = Path.current
var version = default_version
var verbose = false
val getopts = Getopts("""
Usage: isabelle build_zipperposition [OPTIONS]
Options are:
-D DIR target directory (default ".")
-V VERSION version (default: """" + default_version + """")
-v verbose
Build prover component from OPAM repository.
""",
"D:" -> (arg => target_dir = Path.explode(arg)),
"V:" -> (arg => version = arg),
"v" -> (_ => verbose = true))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val progress = new Console_Progress()
build_zipperposition(version = version, verbose = verbose, progress = progress,
target_dir = target_dir)
})
}
diff --git a/src/Pure/Admin/check_sources.scala b/src/Pure/Admin/check_sources.scala
--- a/src/Pure/Admin/check_sources.scala
+++ b/src/Pure/Admin/check_sources.scala
@@ -1,80 +1,80 @@
/* Title: Pure/Admin/check_sources.scala
Author: Makarius
Some sanity checks for Isabelle sources.
*/
package isabelle
object Check_Sources
{
- def check_file(path: Path)
+ def check_file(path: Path): Unit =
{
val file_name = path.implode
val file_pos = path.position
def line_pos(i: Int) = Position.Line_File(i + 1, file_name)
if (space_explode('/', Word.lowercase(path.expand.drop_ext.implode)).contains("aux"))
Output.warning("Illegal file-name on Windows" + Position.here(file_pos))
val bytes = Bytes.read(path)
val content = bytes.text
if (Bytes(content) != bytes) {
Output.warning("Bad UTF8 encoding" + Position.here(file_pos))
}
for { (line, i) <- split_lines(content).iterator.zipWithIndex }
{
try {
Symbol.decode_strict(line)
for { c <- Codepoint.iterator(line); if c > 128 && !Character.isAlphabetic(c) }
{
Output.warning("Suspicious Unicode character " + quote(Codepoint.string(c)) +
Position.here(line_pos(i)))
}
}
catch { case ERROR(msg) => Output.warning(msg + Position.here(line_pos(i))) }
if (line.contains('\t'))
Output.warning("TAB character" + Position.here(line_pos(i)))
}
if (content.contains('\r'))
Output.warning("CR character" + Position.here(file_pos))
if (Word.bidi_detect(content))
Output.warning("Bidirectional Unicode text" + Position.here(file_pos))
}
- def check_hg(root: Path)
+ def check_hg(root: Path): Unit =
{
Output.writeln("Checking " + root + " ...")
val hg = Mercurial.repository(root)
for {
file <- hg.known_files()
if file.endsWith(".thy") || file.endsWith(".ML") || file.endsWith("/ROOT")
} check_file(root + Path.explode(file))
}
/* Isabelle tool wrapper */
val isabelle_tool =
Isabelle_Tool("check_sources", "some sanity checks for Isabelle sources",
Scala_Project.here, args =>
{
val getopts = Getopts("""
Usage: isabelle check_sources [ROOT_DIRS...]
Check .thy, .ML, ROOT against known files of Mercurial ROOT_DIRS.
""")
val specs = getopts(args)
if (specs.isEmpty) getopts.usage()
for (root <- specs) check_hg(Path.explode(root))
})
}
diff --git a/src/Pure/Admin/components.scala b/src/Pure/Admin/components.scala
--- a/src/Pure/Admin/components.scala
+++ b/src/Pure/Admin/components.scala
@@ -1,354 +1,354 @@
/* Title: Pure/Admin/components.scala
Author: Makarius
Isabelle system components.
*/
package isabelle
import java.io.{File => JFile}
object Components
{
/* archive name */
object Archive
{
val suffix: String = ".tar.gz"
def apply(name: String): String =
if (name == "") error("Bad component name: " + quote(name))
else name + suffix
def unapply(archive: String): Option[String] =
{
for {
name0 <- Library.try_unsuffix(suffix, archive)
name <- proper_string(name0)
} yield name
}
def get_name(archive: String): String =
unapply(archive) getOrElse
error("Bad component archive name (expecting .tar.gz): " + quote(archive))
}
/* component collections */
def default_component_repository: String =
Isabelle_System.getenv("ISABELLE_COMPONENT_REPOSITORY")
val default_components_base: Path = Path.explode("$ISABELLE_COMPONENTS_BASE")
def admin(dir: Path): Path = dir + Path.explode("Admin/components")
def contrib(dir: Path = Path.current, name: String = ""): Path =
dir + Path.explode("contrib") + Path.explode(name)
def unpack(dir: Path, archive: Path, progress: Progress = new Progress): String =
{
val name = Archive.get_name(archive.file_name)
progress.echo("Unpacking " + name)
Isabelle_System.gnutar("-xzf " + File.bash_path(archive), dir = dir).check
name
}
def resolve(base_dir: Path, names: List[String],
target_dir: Option[Path] = None,
copy_dir: Option[Path] = None,
- progress: Progress = new Progress)
+ progress: Progress = new Progress): Unit =
{
Isabelle_System.make_directory(base_dir)
for (name <- names) {
val archive_name = Archive(name)
val archive = base_dir + Path.explode(archive_name)
if (!archive.is_file) {
val remote = Components.default_component_repository + "/" + archive_name
progress.echo("Getting " + remote)
Bytes.write(archive, Url.read_bytes(Url(remote)))
}
for (dir <- copy_dir) {
Isabelle_System.make_directory(dir)
Isabelle_System.copy_file(archive, dir)
}
unpack(target_dir getOrElse base_dir, archive, progress = progress)
}
}
- def purge(dir: Path, platform: Platform.Family.Value)
+ def purge(dir: Path, platform: Platform.Family.Value): Unit =
{
def purge_platforms(platforms: String*): Set[String] =
platforms.flatMap(name =>
List("arm64-" + name, "x86-" + name, "x86_64_32-" + name, "x86_64-" + name)).toSet +
"ppc-darwin" + "arm64-linux"
val purge_set =
platform match {
case Platform.Family.linux => purge_platforms("darwin", "cygwin", "windows")
case Platform.Family.macos => purge_platforms("linux", "cygwin", "windows")
case Platform.Family.windows => purge_platforms("linux", "darwin")
}
File.find_files(dir.file,
(file: JFile) => file.isDirectory && purge_set(file.getName),
include_dirs = true).foreach(Isabelle_System.rm_tree)
}
/* component directory content */
def settings(dir: Path = Path.current): Path = dir + Path.explode("etc/settings")
def components(dir: Path = Path.current): Path = dir + Path.explode("etc/components")
def check_dir(dir: Path): Boolean =
settings(dir).is_file || components(dir).is_file
def read_components(dir: Path): List[String] =
split_lines(File.read(components(dir))).filter(_.nonEmpty)
def write_components(dir: Path, lines: List[String]): Unit =
File.write(components(dir), terminate_lines(lines))
/* component repository content */
val components_sha1: Path = Path.explode("~~/Admin/components/components.sha1")
sealed case class SHA1_Digest(sha1: String, file_name: String)
{
override def toString: String = sha1 + " " + file_name
}
def read_components_sha1(lines: List[String] = Nil): List[SHA1_Digest] =
(proper_list(lines) getOrElse split_lines(File.read(components_sha1))).flatMap(line =>
Word.explode(line) match {
case Nil => None
case List(sha1, name) => Some(SHA1_Digest(sha1, name))
case _ => error("Bad components.sha1 entry: " + quote(line))
})
def write_components_sha1(entries: List[SHA1_Digest]): Unit =
File.write(components_sha1, entries.sortBy(_.file_name).mkString("", "\n", "\n"))
/** manage user components **/
val components_path = Path.explode("$ISABELLE_HOME_USER/etc/components")
def read_components(): List[String] =
if (components_path.is_file) Library.trim_split_lines(File.read(components_path))
else Nil
def write_components(lines: List[String]): Unit =
{
Isabelle_System.make_directory(components_path.dir)
File.write(components_path, Library.terminate_lines(lines))
}
def update_components(add: Boolean, path0: Path, progress: Progress = new Progress): Unit =
{
val path = path0.expand.absolute
if (!(path + Path.explode("etc/settings")).is_file &&
!(path + Path.explode("etc/components")).is_file) error("Bad component directory: " + path)
val lines1 = read_components()
val lines2 =
lines1.filter(line =>
line.isEmpty || line.startsWith("#") || !File.eq(Path.explode(line), path))
val lines3 = if (add) lines2 ::: List(path.implode) else lines2
if (lines1 != lines3) write_components(lines3)
val prefix = if (lines1 == lines3) "Unchanged" else if (add) "Added" else "Removed"
progress.echo(prefix + " component " + path)
}
/* main entry point */
def main(args: Array[String]): Unit =
{
Command_Line.tool {
for (arg <- args) {
val add =
if (arg.startsWith("+")) true
else if (arg.startsWith("-")) false
else error("Bad argument: " + quote(arg))
val path = Path.explode(arg.substring(1))
update_components(add, path, progress = new Console_Progress)
}
}
}
/** build and publish components **/
def build_components(
options: Options,
components: List[Path],
progress: Progress = new Progress,
publish: Boolean = false,
force: Boolean = false,
- update_components_sha1: Boolean = false)
+ update_components_sha1: Boolean = false): Unit =
{
val archives: List[Path] =
for (path <- components) yield {
path.file_name match {
case Archive(_) => path
case name =>
if (!path.is_dir) error("Bad component directory: " + path)
else if (!check_dir(path)) {
error("Malformed component directory: " + path +
"\n (requires " + settings() + " or " + Components.components() + ")")
}
else {
val component_path = path.expand
val archive_dir = component_path.dir
val archive_name = Archive(name)
val archive = archive_dir + Path.explode(archive_name)
if (archive.is_file && !force) {
error("Component archive already exists: " + archive)
}
progress.echo("Packaging " + archive_name)
Isabelle_System.gnutar("-czf " + File.bash_path(archive) + " " + Bash.string(name),
dir = archive_dir).check
archive
}
}
}
if ((publish && archives.nonEmpty) || update_components_sha1) {
options.string("isabelle_components_server") match {
case SSH.Target(user, host) =>
using(SSH.open_session(options, host = host, user = user))(ssh =>
{
val components_dir = Path.explode(options.string("isabelle_components_dir"))
val contrib_dir = Path.explode(options.string("isabelle_components_contrib_dir"))
for (dir <- List(components_dir, contrib_dir) if !ssh.is_dir(dir)) {
error("Bad remote directory: " + dir)
}
if (publish) {
for (archive <- archives) {
val archive_name = archive.file_name
val name = Archive.get_name(archive_name)
val remote_component = components_dir + archive.base
val remote_contrib = contrib_dir + Path.explode(name)
// component archive
if (ssh.is_file(remote_component) && !force) {
error("Remote component archive already exists: " + remote_component)
}
progress.echo("Uploading " + archive_name)
ssh.write_file(remote_component, archive)
// contrib directory
val is_standard_component =
Isabelle_System.with_tmp_dir("component")(tmp_dir =>
{
Isabelle_System.gnutar("-xzf " + File.bash_path(archive), dir = tmp_dir).check
check_dir(tmp_dir + Path.explode(name))
})
if (is_standard_component) {
if (ssh.is_dir(remote_contrib)) {
if (force) ssh.rm_tree(remote_contrib)
else error("Remote component directory already exists: " + remote_contrib)
}
progress.echo("Unpacking remote " + archive_name)
ssh.execute("tar -C " + ssh.bash_path(contrib_dir) + " -xzf " +
ssh.bash_path(remote_component)).check
}
else {
progress.echo_warning("No unpacking of non-standard component: " + archive_name)
}
}
}
// remote SHA1 digests
if (update_components_sha1) {
val lines =
for {
entry <- ssh.read_dir(components_dir)
if entry.is_file && entry.name.endsWith(Archive.suffix)
}
yield {
progress.echo("Digesting remote " + entry.name)
ssh.execute("cd " + ssh.bash_path(components_dir) +
"; sha1sum " + Bash.string(entry.name)).check.out
}
write_components_sha1(read_components_sha1(lines))
}
})
case s => error("Bad isabelle_components_server: " + quote(s))
}
}
// local SHA1 digests
{
val new_entries =
for (archive <- archives)
yield {
val file_name = archive.file_name
progress.echo("Digesting local " + file_name)
val sha1 = SHA1.digest(archive).rep
SHA1_Digest(sha1, file_name)
}
val new_names = new_entries.map(_.file_name).toSet
write_components_sha1(
new_entries :::
read_components_sha1().filterNot(entry => new_names.contains(entry.file_name)))
}
}
/* Isabelle tool wrapper */
private val relevant_options =
List("isabelle_components_server", "isabelle_components_dir", "isabelle_components_contrib_dir")
val isabelle_tool =
Isabelle_Tool("build_components", "build and publish Isabelle components",
Scala_Project.here, args =>
{
var publish = false
var update_components_sha1 = false
var force = false
var options = Options.init()
def show_options: String =
cat_lines(relevant_options.map(name => options.options(name).print))
val getopts = Getopts("""
Usage: isabelle build_components [OPTIONS] ARCHIVES... DIRS...
Options are:
-P publish on SSH server (see options below)
-f force: overwrite existing component archives and directories
-o OPTION override Isabelle system OPTION (via NAME=VAL or NAME)
-u update all SHA1 keys in Isabelle repository Admin/components
Build and publish Isabelle components as .tar.gz archives on SSH server,
depending on system options:
""" + Library.prefix_lines(" ", show_options) + "\n",
"P" -> (_ => publish = true),
"f" -> (_ => force = true),
"o:" -> (arg => options = options + arg),
"u" -> (_ => update_components_sha1 = true))
val more_args = getopts(args)
if (more_args.isEmpty && !update_components_sha1) getopts.usage()
val progress = new Console_Progress
build_components(options, more_args.map(Path.explode), progress = progress,
publish = publish, force = force, update_components_sha1 = update_components_sha1)
})
}
diff --git a/src/Pure/Admin/isabelle_cronjob.scala b/src/Pure/Admin/isabelle_cronjob.scala
--- a/src/Pure/Admin/isabelle_cronjob.scala
+++ b/src/Pure/Admin/isabelle_cronjob.scala
@@ -1,635 +1,635 @@
/* Title: Pure/Admin/isabelle_cronjob.scala
Author: Makarius
Main entry point for administrative cronjob at TUM.
*/
package isabelle
import java.nio.file.Files
import scala.annotation.tailrec
object Isabelle_Cronjob
{
/* global resources: owned by main cronjob */
val backup = "lxbroy10:cronjob"
val main_dir: Path = Path.explode("~/cronjob")
val main_state_file: Path = main_dir + Path.explode("run/main.state")
val current_log: Path = main_dir + Path.explode("run/main.log") // owned by log service
val cumulative_log: Path = main_dir + Path.explode("log/main.log") // owned by log service
val isabelle_repos_source = "https://isabelle.sketis.net/repos/isabelle"
val isabelle_repos: Path = main_dir + Path.explode("isabelle")
val afp_repos: Path = main_dir + Path.explode("AFP")
val mailman_archives_dir = Path.explode("~/cronjob/Mailman")
val build_log_dirs =
List(Path.explode("~/log"), Path.explode("~/afp/log"), Path.explode("~/cronjob/log"))
/** logger tasks **/
sealed case class Logger_Task(name: String = "", body: Logger => Unit)
/* init and exit */
def get_rev(): String = Mercurial.repository(isabelle_repos).id()
def get_afp_rev(): String = Mercurial.repository(afp_repos).id()
val init: Logger_Task =
Logger_Task("init", logger =>
{
Isabelle_Devel.make_index()
Mercurial.setup_repository(isabelle_repos_source, isabelle_repos)
Mercurial.setup_repository(AFP.repos_source, afp_repos)
File.write(logger.log_dir + Build_Log.log_filename("isabelle_identify", logger.start_date),
Build_Log.Identify.content(logger.start_date, Some(get_rev()), Some(get_afp_rev())))
Isabelle_System.bash(
"""rsync -a --include="*/" --include="plain_identify*" --exclude="*" """ +
Bash.string(backup + "/log/.") + " " + File.bash_path(main_dir) + "/log/.").check
if (!Isabelle_Devel.cronjob_log.is_file)
Files.createSymbolicLink(Isabelle_Devel.cronjob_log.file.toPath, current_log.file.toPath)
})
val exit: Logger_Task =
Logger_Task("exit", logger =>
{
Isabelle_System.bash(
"rsync -a " + File.bash_path(main_dir) + "/log/." + " " + Bash.string(backup) + "/log/.")
.check
})
/* Mailman archives */
val mailman_archives: Logger_Task =
Logger_Task("mailman_archives", logger =>
{
Mailman.isabelle_users.download(mailman_archives_dir)
Mailman.isabelle_dev.download(mailman_archives_dir)
})
/* build release */
val build_release: Logger_Task =
Logger_Task("build_release", logger =>
{
Isabelle_Devel.release_snapshot(logger.options, rev = get_rev(), afp_rev = get_afp_rev())
})
/* remote build_history */
sealed case class Item(
known: Boolean,
isabelle_version: String,
afp_version: Option[String],
pull_date: Date)
{
def unknown: Boolean = !known
def versions: (String, Option[String]) = (isabelle_version, afp_version)
def known_versions(rev: String, afp_rev: Option[String]): Boolean =
known && rev != "" && isabelle_version == rev &&
(afp_rev.isEmpty || afp_rev.get != "" && afp_version == afp_rev)
}
def recent_items(db: SQL.Database,
days: Int, rev: String, afp_rev: Option[String], sql: SQL.Source): List[Item] =
{
val afp = afp_rev.isDefined
val select =
Build_Log.Data.select_recent_versions(
days = days, rev = rev, afp_rev = afp_rev, sql = "WHERE " + sql)
db.using_statement(select)(stmt =>
stmt.execute_query().iterator(res =>
{
val known = res.bool(Build_Log.Data.known)
val isabelle_version = res.string(Build_Log.Prop.isabelle_version)
val afp_version = if (afp) proper_string(res.string(Build_Log.Prop.afp_version)) else None
val pull_date = res.date(Build_Log.Data.pull_date(afp))
Item(known, isabelle_version, afp_version, pull_date)
}).toList)
}
def unknown_runs(items: List[Item]): List[List[Item]] =
{
val (run, rest) = Library.take_prefix[Item](_.unknown, items.dropWhile(_.known))
if (run.nonEmpty) run :: unknown_runs(rest) else Nil
}
sealed case class Remote_Build(
description: String,
host: String,
actual_host: String = "",
user: String = "",
port: Int = 0,
proxy_host: String = "",
proxy_user: String = "",
proxy_port: Int = 0,
self_update: Boolean = false,
historic: Boolean = false,
history: Int = 0,
history_base: String = "build_history_base",
java_heap: String = "",
options: String = "",
args: String = "",
afp: Boolean = false,
bulky: Boolean = false,
more_hosts: List[String] = Nil,
detect: SQL.Source = "",
active: Boolean = true)
{
def ssh_session(context: SSH.Context): SSH.Session =
context.open_session(host = host, user = user, port = port, actual_host = actual_host,
proxy_host = proxy_host, proxy_user = proxy_user, proxy_port = proxy_port,
permissive = proxy_host.nonEmpty)
def sql: SQL.Source =
Build_Log.Prop.build_engine + " = " + SQL.string(Build_History.engine) + " AND " +
SQL.member(Build_Log.Prop.build_host.ident, host :: more_hosts) +
(if (detect == "") "" else " AND " + SQL.enclose(detect))
def profile: Build_Status.Profile =
Build_Status.Profile(description, history = history, afp = afp, bulky = bulky, sql = sql)
def pick(
options: Options,
rev: String = "",
filter: Item => Boolean = _ => true): Option[(String, Option[String])] =
{
val afp_rev = if (afp) Some(get_afp_rev()) else None
val store = Build_Log.store(options)
using(store.open_database())(db =>
{
def pick_days(days: Int, gap: Int): Option[(String, Option[String])] =
{
val items = recent_items(db, days, rev, afp_rev, sql).filter(filter)
def runs = unknown_runs(items).filter(run => run.length >= gap)
if (historic || items.exists(_.known_versions(rev, afp_rev))) {
val longest_run =
(List.empty[Item] /: runs)({ case (item1, item2) =>
if (item1.length >= item2.length) item1 else item2
})
if (longest_run.isEmpty) None
else Some(longest_run(longest_run.length / 2).versions)
}
else if (rev != "") Some((rev, afp_rev))
else runs.flatten.headOption.map(_.versions)
}
pick_days(options.int("build_log_history") max history, 2) orElse
pick_days(200, 5) orElse
pick_days(2000, 1)
})
}
def build_history_options: String =
" -h " + Bash.string(host) + " " +
(java_heap match {
case "" => ""
case h =>
"-e 'ISABELLE_TOOL_JAVA_OPTIONS=\"$ISABELLE_TOOL_JAVA_OPTIONS -Xmx" + h + "\"' "
}) + options
}
val remote_builds_old: List[Remote_Build] =
List(
Remote_Build("Linux A", "lxbroy9",
java_heap = "2g", options = "-m32 -B -M1x2,2", args = "-N -g timing"),
Remote_Build("Linux Benchmarks", "lxbroy5", historic = true, history = 90,
java_heap = "2g",
options = "-m32 -B -M1x2,2 -t Benchmarks" +
" -e ISABELLE_GHC=ghc -e ISABELLE_MLTON=mlton -e ISABELLE_OCAML=ocaml" +
" -e ISABELLE_OCAMLC=ocamlc -e ISABELLE_OCAMLFIND=ocamlfind -e ISABELLE_SMLNJ=sml" +
" -e ISABELLE_SWIPL=swipl",
args = "-N -a -d '~~/src/Benchmarks'",
detect = Build_Log.Prop.build_tags + " = " + SQL.string("Benchmarks")),
Remote_Build("macOS 10.14 Mojave (Old)", "lapnipkow3",
options = "-m32 -M1,2 -e ISABELLE_GHC_SETUP=true -p pide_session=false",
self_update = true, args = "-a -d '~~/src/Benchmarks'"),
Remote_Build("AFP old bulky", "lrzcloud1", self_update = true,
proxy_host = "lxbroy10", proxy_user = "i21isatest",
options = "-m64 -M6 -U30000 -s10 -t AFP",
args = "-g large -g slow",
afp = true,
bulky = true,
detect = Build_Log.Prop.build_tags + " = " + SQL.string("AFP")),
Remote_Build("AFP old", "lxbroy7",
args = "-N -X large -X slow",
afp = true,
detect = Build_Log.Prop.build_tags + " = " + SQL.string("AFP")),
Remote_Build("Poly/ML 5.7 Linux", "lxbroy8",
history_base = "37074e22e8be",
options = "-m32 -B -M1x2,2 -t polyml-5.7 -i 'init_component /home/isabelle/contrib/polyml-5.7'",
args = "-N -g timing",
detect = Build_Log.Prop.build_tags + " = " + SQL.string("polyml-5.7") + " AND " +
Build_Log.Settings.ML_OPTIONS + " <> " + SQL.string("-H 500")),
Remote_Build("Poly/ML 5.7.1 Linux", "lxbroy8",
history_base = "a9d5b59c3e12",
options = "-m32 -B -M1x2,2 -t polyml-5.7.1-pre2 -i 'init_component /home/isabelle/contrib/polyml-test-905dae2ebfda'",
args = "-N -g timing",
detect =
Build_Log.Prop.build_tags + " = " + SQL.string("polyml-5.7.1-pre1") + " OR " +
Build_Log.Prop.build_tags + " = " + SQL.string("polyml-5.7.1-pre2")),
Remote_Build("Poly/ML 5.7 macOS", "macbroy2",
history_base = "37074e22e8be",
options = "-m32 -B -M1x4,4 -t polyml-5.7 -i 'init_component /home/isabelle/contrib/polyml-5.7'",
args = "-a",
detect = Build_Log.Prop.build_tags + " = " + SQL.string("polyml-5.7")),
Remote_Build("Poly/ML 5.7.1 macOS", "macbroy2",
history_base = "a9d5b59c3e12",
options = "-m32 -B -M1x4,4 -t polyml-5.7.1-pre2 -i 'init_component /home/isabelle/contrib/polyml-test-905dae2ebfda'",
args = "-a",
detect =
Build_Log.Prop.build_tags + " = " + SQL.string("polyml-5.7.1-pre1") + " OR " +
Build_Log.Prop.build_tags + " = " + SQL.string("polyml-5.7.1-pre2")),
Remote_Build("macOS", "macbroy2",
options = "-m32 -M8" +
" -e ISABELLE_GHC=ghc -e ISABELLE_MLTON=mlton -e ISABELLE_OCAML=ocaml" +
" -e ISABELLE_OCAMLC=ocamlc -e ISABELLE_OCAML_SETUP=true" +
" -e ISABELLE_OPAM_ROOT=\"$ISABELLE_HOME/opam\"" +
" -e ISABELLE_SMLNJ=/home/isabelle/smlnj/110.85/bin/sml" +
" -p pide_session=false",
args = "-a",
detect = Build_Log.Prop.build_tags.undefined,
history_base = "2c0f24e927dd"),
Remote_Build("macOS, quick_and_dirty", "macbroy2",
options = "-m32 -M8 -t quick_and_dirty -p pide_session=false", args = "-a -o quick_and_dirty",
detect = Build_Log.Prop.build_tags + " = " + SQL.string("quick_and_dirty"),
history_base = "2c0f24e927dd"),
Remote_Build("macOS, skip_proofs", "macbroy2",
options = "-m32 -M8 -t skip_proofs -p pide_session=false", args = "-a -o skip_proofs",
detect = Build_Log.Prop.build_tags + " = " + SQL.string("skip_proofs"),
history_base = "2c0f24e927dd"),
Remote_Build("Poly/ML test", "lxbroy8",
options = "-m32 -B -M1x2,2 -t polyml-test -i 'init_component /home/isabelle/contrib/polyml-5.7-20170217'",
args = "-N -g timing",
detect = Build_Log.Prop.build_tags + " = " + SQL.string("polyml-test")),
Remote_Build("macOS 10.12 Sierra", "macbroy30", options = "-m32 -M2 -p pide_session=false", args = "-a",
detect = Build_Log.Prop.build_start + " > date '2017-03-03'"),
Remote_Build("macOS 10.10 Yosemite", "macbroy31", options = "-m32 -M2 -p pide_session=false", args = "-a"),
Remote_Build("macOS 10.8 Mountain Lion", "macbroy30", options = "-m32 -M2", args = "-a",
detect = Build_Log.Prop.build_start + " < date '2017-03-03'")) :::
{
for { (n, hosts) <- List(1 -> List("lxbroy6"), 2 -> List("lxbroy8", "lxbroy5")) }
yield {
Remote_Build("AFP old", host = hosts.head, more_hosts = hosts.tail,
options = "-m32 -M1x2 -t AFP -P" + n +
" -e ISABELLE_GHC=ghc" +
" -e ISABELLE_MLTON=mlton" +
" -e ISABELLE_OCAML=ocaml -e ISABELLE_OCAMLC=ocamlc -e ISABELLE_OCAMLFIND=ocamlfind" +
" -e ISABELLE_SMLNJ=sml",
args = "-N -X large -X slow",
afp = true,
detect = Build_Log.Prop.build_tags + " = " + SQL.string("AFP"))
}
}
val remote_builds1: List[List[Remote_Build]] =
{
List(
List(Remote_Build("Linux B", "lxbroy10", historic = true, history = 90,
options = "-m32 -B -M1x4,2,4,6", args = "-N -g timing")),
List(Remote_Build("macOS 10.13 High Sierra", "lapbroy68",
options = "-m32 -B -M1,2,4 -e ISABELLE_GHC_SETUP=true -p pide_session=false",
self_update = true, args = "-a -d '~~/src/Benchmarks'")),
List(
Remote_Build("macOS 11.1 Big Sur", "mini1",
options = "-m32 -B -M1x2,2,4 -p pide_session=false" +
" -e ISABELLE_OCAML=ocaml -e ISABELLE_OCAMLC=ocamlc -e ISABELLE_OCAML_SETUP=true" +
" -e ISABELLE_GHC_SETUP=true" +
" -e ISABELLE_MLTON=/usr/local/bin/mlton" +
" -e ISABELLE_SMLNJ=/usr/local/smlnj/bin/sml" +
" -e ISABELLE_SWIPL=/usr/local/bin/swipl",
self_update = true, args = "-a -d '~~/src/Benchmarks'")),
List(
Remote_Build("macOS 10.14 Mojave", "mini2",
options = "-m32 -B -M1x2,2,4 -p pide_session=false" +
" -e ISABELLE_OCAML=ocaml -e ISABELLE_OCAMLC=ocamlc -e ISABELLE_OCAML_SETUP=true" +
" -e ISABELLE_GHC_SETUP=true" +
" -e ISABELLE_MLTON=/usr/local/bin/mlton" +
" -e ISABELLE_SMLNJ=/usr/local/smlnj/bin/sml" +
" -e ISABELLE_SWIPL=/usr/local/bin/swipl",
self_update = true, args = "-a -d '~~/src/Benchmarks'"),
Remote_Build("macOS, quick_and_dirty", "mini2",
options = "-m32 -M4 -t quick_and_dirty -p pide_session=false",
self_update = true, args = "-a -o quick_and_dirty",
detect = Build_Log.Prop.build_tags + " = " + SQL.string("quick_and_dirty")),
Remote_Build("macOS, skip_proofs", "mini2",
options = "-m32 -M4 -t skip_proofs -p pide_session=false", args = "-a -o skip_proofs",
detect = Build_Log.Prop.build_tags + " = " + SQL.string("skip_proofs"))),
List(Remote_Build("macOS 10.15 Catalina", "laramac01", user = "makarius",
proxy_host = "laraserver", proxy_user = "makarius",
self_update = true,
options = "-m32 -M4 -e ISABELLE_GHC_SETUP=true -p pide_session=false",
args = "-a -d '~~/src/Benchmarks'")),
List(
Remote_Build("Windows", "vmnipkow9", historic = true, history = 90, self_update = true,
options = "-m32 -M4" +
" -C /cygdrive/d/isatest/contrib" +
" -e ISABELLE_OCAML=ocaml -e ISABELLE_OCAMLC=ocamlc -e ISABELLE_OCAML_SETUP=true" +
" -e ISABELLE_GHC_SETUP=true" +
" -e ISABELLE_SMLNJ=/usr/local/smlnj-110.81/bin/sml",
args = "-a",
detect =
Build_Log.Settings.ML_PLATFORM + " = " + SQL.string("x86-windows") + " OR " +
Build_Log.Settings.ML_PLATFORM + " = " + SQL.string("x86_64_32-windows")),
Remote_Build("Windows", "vmnipkow9", historic = true, history = 90, self_update = true,
options = "-m64 -M4" +
" -C /cygdrive/d/isatest/contrib" +
" -e ISABELLE_OCAML=ocaml -e ISABELLE_OCAMLC=ocamlc -e ISABELLE_OCAML_SETUP=true" +
" -e ISABELLE_GHC_SETUP=true" +
" -e ISABELLE_SMLNJ=/usr/local/smlnj-110.81/bin/sml",
args = "-a",
detect = Build_Log.Settings.ML_PLATFORM + " = " + SQL.string("x86_64-windows"))))
}
val remote_builds2: List[List[Remote_Build]] =
List(
List(
Remote_Build("AFP", "lrzcloud2", actual_host = "10.195.4.41", self_update = true,
proxy_host = "lxbroy10", proxy_user = "i21isatest",
java_heap = "8g",
options = "-m32 -M1x6 -t AFP" +
" -e ISABELLE_GHC=ghc" +
" -e ISABELLE_MLTON=mlton" +
" -e ISABELLE_OCAML=ocaml -e ISABELLE_OCAMLC=ocamlc -e ISABELLE_OCAMLFIND=ocamlfind" +
" -e ISABELLE_SMLNJ=sml",
args = "-a -X large -X slow",
afp = true,
detect = Build_Log.Prop.build_tags + " = " + SQL.string("AFP")),
Remote_Build("AFP", "lrzcloud2", actual_host = "10.195.4.41", self_update = true,
proxy_host = "lxbroy10", proxy_user = "i21isatest",
java_heap = "8g",
options = "-m64 -M8 -U30000 -s10 -t AFP",
args = "-g large -g slow",
afp = true,
bulky = true,
detect = Build_Log.Prop.build_tags + " = " + SQL.string("AFP"))))
def remote_build_history(rev: String, afp_rev: Option[String], i: Int, r: Remote_Build)
: Logger_Task =
{
val task_name = "build_history-" + r.host
Logger_Task(task_name, logger =>
{
using(r.ssh_session(logger.ssh_context))(ssh =>
{
val results =
Build_History.remote_build_history(ssh,
isabelle_repos,
isabelle_repos.ext(r.host),
isabelle_identifier = "cronjob_build_history",
self_update = r.self_update,
rev = rev,
afp_rev = afp_rev,
options =
" -N " + Bash.string(task_name) + (if (i < 0) "" else "_" + (i + 1).toString) +
" -R " + Bash.string(Components.default_component_repository) +
" -C '$USER_HOME/.isabelle/contrib' -f " +
r.build_history_options,
args = "-o timeout=10800 " + r.args)
for ((log_name, bytes) <- results) {
logger.log(Date.now(), log_name)
Bytes.write(logger.log_dir + Path.explode(log_name), bytes)
}
})
})
}
val build_status_profiles: List[Build_Status.Profile] =
(remote_builds_old :: remote_builds1 ::: remote_builds2).flatten.map(_.profile)
/** task logging **/
object Log_Service
{
def apply(options: Options, progress: Progress = new Progress): Log_Service =
new Log_Service(SSH.init_context(options), progress)
}
class Log_Service private(val ssh_context: SSH.Context, progress: Progress)
{
current_log.file.delete
private val thread: Consumer_Thread[String] =
Consumer_Thread.fork("cronjob: logger", daemon = true)(
consume = (text: String) =>
{ // critical
File.append(current_log, text + "\n")
File.append(cumulative_log, text + "\n")
progress.echo(text)
true
})
- def shutdown() { thread.shutdown() }
+ def shutdown(): Unit = { thread.shutdown() }
val hostname: String = Isabelle_System.hostname()
def log(date: Date, task_name: String, msg: String): Unit =
if (task_name != "")
thread.send(
"[" + Build_Log.print_date(date) + ", " + hostname + ", " + task_name + "]: " + msg)
def start_logger(start_date: Date, task_name: String): Logger =
new Logger(this, start_date, task_name)
- def run_task(start_date: Date, task: Logger_Task)
+ def run_task(start_date: Date, task: Logger_Task): Unit =
{
val logger = start_logger(start_date, task.name)
val res = Exn.capture { task.body(logger) }
val end_date = Date.now()
val err =
res match {
case Exn.Res(_) => None
case Exn.Exn(exn) =>
Output.writeln("Exception trace for " + quote(task.name) + ":")
exn.printStackTrace()
val first_line = split_lines(Exn.message(exn)).headOption getOrElse "exception"
Some(first_line)
}
logger.log_end(end_date, err)
}
def fork_task(start_date: Date, task: Logger_Task): Task =
new Task(task.name, run_task(start_date, task))
}
class Logger private[Isabelle_Cronjob](
val log_service: Log_Service, val start_date: Date, val task_name: String)
{
def ssh_context: SSH.Context = log_service.ssh_context
def options: Options = ssh_context.options
def log(date: Date, msg: String): Unit = log_service.log(date, task_name, msg)
- def log_end(end_date: Date, err: Option[String])
+ def log_end(end_date: Date, err: Option[String]): Unit =
{
val elapsed_time = end_date.time - start_date.time
val msg =
(if (err.isEmpty) "finished" else "ERROR " + err.get) +
(if (elapsed_time.seconds < 3.0) "" else " (" + elapsed_time.message_hms + " elapsed time)")
log(end_date, msg)
}
val log_dir = Isabelle_System.make_directory(main_dir + Build_Log.log_subdir(start_date))
log(start_date, "started")
}
class Task private[Isabelle_Cronjob](name: String, body: => Unit)
{
private val future: Future[Unit] = Future.thread("cronjob: " + name) { body }
def is_finished: Boolean = future.is_finished
}
/** cronjob **/
- def cronjob(progress: Progress, exclude_task: Set[String])
+ def cronjob(progress: Progress, exclude_task: Set[String]): Unit =
{
/* soft lock */
val still_running =
try { Some(File.read(main_state_file)) }
catch { case ERROR(_) => None }
still_running match {
case None | Some("") =>
case Some(running) =>
error("Isabelle cronjob appears to be still running: " + running)
}
/* log service */
val log_service = Log_Service(Options.init(), progress = progress)
- def run(start_date: Date, task: Logger_Task) { log_service.run_task(start_date, task) }
+ def run(start_date: Date, task: Logger_Task): Unit = log_service.run_task(start_date, task)
- def run_now(task: Logger_Task) { run(Date.now(), task) }
+ def run_now(task: Logger_Task): Unit = run(Date.now(), task)
/* structured tasks */
def SEQ(tasks: List[Logger_Task]): Logger_Task = Logger_Task(body = _ =>
for (task <- tasks.iterator if !exclude_task(task.name) || task.name == "")
run_now(task))
def PAR(tasks: List[Logger_Task]): Logger_Task = Logger_Task(body = _ =>
{
- @tailrec def join(running: List[Task])
+ @tailrec def join(running: List[Task]): Unit =
{
running.partition(_.is_finished) match {
case (Nil, Nil) =>
case (Nil, _ :: _) => Time.seconds(0.5).sleep; join(running)
case (_ :: _, remaining) => join(remaining)
}
}
val start_date = Date.now()
val running =
for (task <- tasks if !exclude_task(task.name))
yield log_service.fork_task(start_date, task)
join(running)
})
/* repository structure */
val hg = Mercurial.repository(isabelle_repos)
val hg_graph = hg.graph()
def history_base_filter(r: Remote_Build): Item => Boolean =
{
val base_rev = hg.id(r.history_base)
val nodes = hg_graph.all_succs(List(base_rev)).toSet
(item: Item) => nodes(item.isabelle_version)
}
/* main */
val main_start_date = Date.now()
File.write(main_state_file, main_start_date + " " + log_service.hostname)
run(main_start_date,
Logger_Task("isabelle_cronjob", logger =>
run_now(
SEQ(List(
init,
PAR(List(mailman_archives, build_release)),
PAR(
List(remote_builds1, remote_builds2).map(remote_builds =>
SEQ(List(
PAR(remote_builds.map(_.filter(_.active)).map(seq =>
SEQ(
for {
(r, i) <- (if (seq.length <= 1) seq.map((_, -1)) else seq.zipWithIndex)
(rev, afp_rev) <- r.pick(logger.options, hg.id(), history_base_filter(r))
} yield remote_build_history(rev, afp_rev, i, r)))),
Logger_Task("jenkins_logs", _ =>
Jenkins.download_logs(logger.options, Jenkins.build_log_jobs, main_dir)),
Logger_Task("build_log_database",
logger => Isabelle_Devel.build_log_database(logger.options, build_log_dirs)),
Logger_Task("build_status",
logger => Isabelle_Devel.build_status(logger.options)))))),
exit)))))
log_service.shutdown()
main_state_file.file.delete
}
/** command line entry point **/
- def main(args: Array[String])
+ def main(args: Array[String]): Unit =
{
Command_Line.tool {
var force = false
var verbose = false
var exclude_task = Set.empty[String]
val getopts = Getopts("""
Usage: Admin/cronjob/main [OPTIONS]
Options are:
-f apply force to do anything
-v verbose
-x NAME exclude tasks with this name
""",
"f" -> (_ => force = true),
"v" -> (_ => verbose = true),
"x:" -> (arg => exclude_task += arg))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val progress = if (verbose) new Console_Progress() else new Progress
if (force) cronjob(progress, exclude_task)
else error("Need to apply force to do anything")
}
}
}
diff --git a/src/Pure/Admin/isabelle_devel.scala b/src/Pure/Admin/isabelle_devel.scala
--- a/src/Pure/Admin/isabelle_devel.scala
+++ b/src/Pure/Admin/isabelle_devel.scala
@@ -1,76 +1,76 @@
/* Title: Pure/Admin/isabelle_devel.scala
Author: Makarius
Website for Isabelle development resources.
*/
package isabelle
object Isabelle_Devel
{
val RELEASE_SNAPSHOT = "release_snapshot"
val BUILD_LOG_DB = "build_log.db"
val BUILD_STATUS = "build_status"
val CRONJOB_LOG = "cronjob-main.log"
val root: Path = Path.explode("~/html-data/devel")
val cronjob_log: Path = root + Path.basic(CRONJOB_LOG)
/* index */
- def make_index()
+ def make_index(): Unit =
{
val redirect = "https://isabelle-dev.sketis.net/home/menu/view/20"
HTML.write_document(root, "index.html",
List(
XML.Elem(Markup("meta",
List("http-equiv" -> "Refresh", "content" -> ("0; url=" + redirect))), Nil)),
List(HTML.link(redirect, HTML.text("Isabelle Development Resources"))))
}
/* release snapshot */
def release_snapshot(
options: Options,
rev: String = "",
afp_rev: String = "",
- parallel_jobs: Int = 1)
+ parallel_jobs: Int = 1): Unit =
{
Isabelle_System.with_tmp_dir("isadist")(base_dir =>
{
Isabelle_System.update_directory(root + Path.explode(RELEASE_SNAPSHOT),
website_dir =>
Build_Release.build_release(base_dir, options, rev = rev, afp_rev = afp_rev,
parallel_jobs = parallel_jobs,
build_sessions = List(Isabelle_System.getenv("ISABELLE_LOGIC")),
website = Some(website_dir)))
})
}
/* maintain build_log database */
- def build_log_database(options: Options, log_dirs: List[Path])
+ def build_log_database(options: Options, log_dirs: List[Path]): Unit =
{
val store = Build_Log.store(options)
using(store.open_database())(db =>
{
store.update_database(db, log_dirs)
store.update_database(db, log_dirs, ml_statistics = true)
store.snapshot_database(db, root + Path.explode(BUILD_LOG_DB))
})
}
/* present build status */
- def build_status(options: Options)
+ def build_status(options: Options): Unit =
{
Isabelle_System.update_directory(root + Path.explode(BUILD_STATUS),
dir => Build_Status.build_status(options, target_dir = dir, ml_statistics = true))
}
}
diff --git a/src/Pure/Admin/jenkins.scala b/src/Pure/Admin/jenkins.scala
--- a/src/Pure/Admin/jenkins.scala
+++ b/src/Pure/Admin/jenkins.scala
@@ -1,147 +1,147 @@
/* Title: Pure/Admin/jenkins.scala
Author: Makarius
Support for Jenkins continuous integration service.
*/
package isabelle
import java.net.URL
import scala.util.matching.Regex
object Jenkins
{
/* server API */
def root(): String =
Isabelle_System.getenv_strict("ISABELLE_JENKINS_ROOT")
def invoke(url: String, args: String*): Any =
{
val req = url + "/api/json?" + args.mkString("&")
val result = Url.read(req)
try { JSON.parse(result) }
catch { case ERROR(_) => error("Malformed JSON from " + quote(req)) }
}
/* build jobs */
def build_job_names(): List[String] =
for {
job <- JSON.array(invoke(root()), "jobs").getOrElse(Nil)
_class <- JSON.string(job, "_class")
if _class == "hudson.model.FreeStyleProject"
name <- JSON.string(job, "name")
} yield name
def download_logs(
- options: Options, job_names: List[String], dir: Path, progress: Progress = new Progress)
+ options: Options, job_names: List[String], dir: Path, progress: Progress = new Progress): Unit =
{
val store = Sessions.store(options)
val infos = job_names.flatMap(build_job_infos)
Par_List.map((info: Job_Info) => info.download_log(store, dir, progress), infos)
}
/* build log status */
val build_log_jobs = List("isabelle-nightly-benchmark", "isabelle-nightly-slow")
val build_status_profiles: List[Build_Status.Profile] =
build_log_jobs.map(job_name =>
Build_Status.Profile("jenkins " + job_name,
sql =
Build_Log.Prop.build_engine + " = " + SQL.string(Build_Log.Jenkins.engine) + " AND " +
Build_Log.Data.session_name + " <> " + SQL.string("Pure") + " AND " +
Build_Log.Data.status + " = " + SQL.string(Build_Log.Session_Status.finished.toString) +
" AND " + Build_Log.Data.log_name + " LIKE " + SQL.string("%" + job_name)))
/* job info */
sealed case class Job_Info(
job_name: String,
timestamp: Long,
main_log: URL,
session_logs: List[(String, String, URL)])
{
val date: Date = Date(Time.ms(timestamp), Date.timezone_berlin)
def log_filename: Path =
Build_Log.log_filename(Build_Log.Jenkins.engine, date, List(job_name))
def read_ml_statistics(store: Sessions.Store, session_name: String): List[Properties.T] =
{
def get_log(ext: String): Option[URL] =
session_logs.collectFirst({ case (a, b, url) if a == session_name && b == ext => url })
get_log("db") match {
case Some(url) =>
Isabelle_System.with_tmp_file(session_name, "db") { database =>
Bytes.write(database, Bytes.read(url))
using(SQLite.open_database(database))(db => store.read_ml_statistics(db, session_name))
}
case None =>
get_log("gz") match {
case Some(url) =>
val log_file = Build_Log.Log_File(session_name, Url.read_gzip(url))
log_file.parse_session_info(ml_statistics = true).ml_statistics
case None => Nil
}
}
}
- def download_log(store: Sessions.Store, dir: Path, progress: Progress = new Progress)
+ def download_log(store: Sessions.Store, dir: Path, progress: Progress = new Progress): Unit =
{
val log_dir = dir + Build_Log.log_subdir(date)
val log_path = log_dir + log_filename.xz
if (!log_path.is_file) {
progress.echo(log_path.expand.implode)
Isabelle_System.make_directory(log_dir)
val ml_statistics =
session_logs.map(_._1).distinct.sorted.flatMap(session_name =>
read_ml_statistics(store, session_name).
map(props => (Build_Log.SESSION_NAME -> session_name) :: props))
File.write_xz(log_path,
terminate_lines(Url.read(main_log) ::
ml_statistics.map(Protocol.ML_Statistics_Marker.apply)),
XZ.options(6))
}
}
}
def build_job_infos(job_name: String): List[Job_Info] =
{
val Session_Log = new Regex("""^.*/log/([^/]+)\.(db|gz)$""")
val infos =
for {
build <-
JSON.array(
invoke(root() + "/job/" + job_name, "tree=allBuilds[number,timestamp,artifacts[*]]"),
"allBuilds").getOrElse(Nil)
number <- JSON.int(build, "number")
timestamp <- JSON.long(build, "timestamp")
} yield {
val job_prefix = root() + "/job/" + job_name + "/" + number
val main_log = Url(job_prefix + "/consoleText")
val session_logs =
for {
artifact <- JSON.array(build, "artifacts").getOrElse(Nil)
log_path <- JSON.string(artifact, "relativePath")
(name, ext) <- (log_path match { case Session_Log(a, b) => Some((a, b)) case _ => None })
} yield (name, ext, Url(job_prefix + "/artifact/" + log_path))
Job_Info(job_name, timestamp, main_log, session_logs)
}
infos.sortBy(info => - info.timestamp)
}
}
diff --git a/src/Pure/Admin/other_isabelle.scala b/src/Pure/Admin/other_isabelle.scala
--- a/src/Pure/Admin/other_isabelle.scala
+++ b/src/Pure/Admin/other_isabelle.scala
@@ -1,120 +1,120 @@
/* Title: Pure/Admin/other_isabelle.scala
Author: Makarius
Manage other Isabelle distributions.
*/
package isabelle
object Other_Isabelle
{
def apply(isabelle_home: Path,
isabelle_identifier: String = "",
user_home: Path = Path.explode("$USER_HOME"),
progress: Progress = new Progress): Other_Isabelle =
new Other_Isabelle(isabelle_home.canonical, isabelle_identifier, user_home, progress)
}
class Other_Isabelle(
val isabelle_home: Path,
val isabelle_identifier: String,
user_home: Path,
progress: Progress)
{
other_isabelle =>
override def toString: String = isabelle_home.toString
if (proper_string(System.getenv("ISABELLE_SETTINGS_PRESENT")).isDefined)
error("Cannot initialize with enclosing ISABELLE_SETTINGS_PRESENT")
/* static system */
def bash(
script: String,
redirect: Boolean = false,
echo: Boolean = false,
strict: Boolean = true): Process_Result =
progress.bash(
"export USER_HOME=" + File.bash_path(user_home) + "\n" +
Isabelle_System.export_isabelle_identifier(isabelle_identifier) + script,
env = null, cwd = isabelle_home.file, redirect = redirect, echo = echo, strict = strict)
def apply(
cmdline: String,
redirect: Boolean = false,
echo: Boolean = false,
strict: Boolean = true): Process_Result =
bash("bin/isabelle " + cmdline, redirect = redirect, echo = echo, strict = strict)
def resolve_components(echo: Boolean): Unit =
other_isabelle(
"env ISABELLE_TOOLS=" + Bash.string(Isabelle_System.getenv("ISABELLE_TOOLS")) +
" isabelle components -a", redirect = true, echo = echo).check
def getenv(name: String): String =
other_isabelle("getenv -b " + Bash.string(name)).check.out
val isabelle_home_user: Path = Path.explode(getenv("ISABELLE_HOME_USER"))
val etc: Path = isabelle_home_user + Path.explode("etc")
val etc_settings: Path = etc + Path.explode("settings")
val etc_preferences: Path = etc + Path.explode("preferences")
def copy_fonts(target_dir: Path): Unit =
Isabelle_Fonts.make_entries(getenv = getenv, hidden = true).
foreach(entry => Isabelle_System.copy_file(entry.path, target_dir))
/* components */
def init_components(
component_repository: String = Components.default_component_repository,
components_base: Path = Components.default_components_base,
catalogs: List[String] = Nil,
components: List[String] = Nil): List[String] =
{
val dir = Components.admin(isabelle_home)
("ISABELLE_COMPONENT_REPOSITORY=" + Bash.string(component_repository)) ::
catalogs.map(name =>
"init_components " + File.bash_path(components_base) + " " +
File.bash_path(dir + Path.basic(name))) :::
components.map(name =>
"init_component " + File.bash_path(components_base + Path.basic(name)))
}
/* settings */
def clean_settings(): Boolean =
if (!etc_settings.is_file) true
else if (File.read(etc_settings).startsWith("# generated by Isabelle")) {
etc_settings.file.delete; true
}
else false
- def init_settings(settings: List[String])
+ def init_settings(settings: List[String]): Unit =
{
if (!clean_settings())
error("Cannot proceed with existing user settings file: " + etc_settings)
Isabelle_System.make_directory(etc_settings.dir)
File.write(etc_settings,
"# generated by Isabelle " + Date.now() + "\n" +
"#-*- shell-script -*- :mode=shellscript:\n" +
settings.mkString("\n", "\n", "\n"))
}
/* cleanup */
- def cleanup()
+ def cleanup(): Unit =
{
clean_settings()
etc.file.delete
isabelle_home_user.file.delete
}
}
diff --git a/src/Pure/Concurrent/consumer_thread.scala b/src/Pure/Concurrent/consumer_thread.scala
--- a/src/Pure/Concurrent/consumer_thread.scala
+++ b/src/Pure/Concurrent/consumer_thread.scala
@@ -1,124 +1,124 @@
/* Title: Pure/Concurrent/consumer_thread.scala
Author: Makarius
Consumer thread with unbounded queueing of requests, and optional
acknowledgment.
*/
package isabelle
import scala.annotation.tailrec
object Consumer_Thread
{
def fork_bulk[A](name: String = "", daemon: Boolean = false)(
bulk: A => Boolean,
consume: List[A] => (List[Exn.Result[Unit]], Boolean),
finish: () => Unit = () => ()): Consumer_Thread[A] =
new Consumer_Thread[A](name, daemon, bulk, consume, finish)
def fork[A](name: String = "", daemon: Boolean = false)(
consume: A => Boolean,
finish: () => Unit = () => ()): Consumer_Thread[A] =
{
def consume_single(args: List[A]): (List[Exn.Result[Unit]], Boolean) =
{
assert(args.length == 1)
Exn.capture { consume(args.head) } match {
case Exn.Res(continue) => (List(Exn.Res(())), continue)
case Exn.Exn(exn) => (List(Exn.Exn(exn)), true)
}
}
fork_bulk(name = name, daemon = daemon)(_ => false, consume_single, finish = finish)
}
}
final class Consumer_Thread[A] private(
name: String, daemon: Boolean,
bulk: A => Boolean,
consume: List[A] => (List[Exn.Result[Unit]], Boolean),
finish: () => Unit)
{
/* thread */
private var active = true
private val mailbox = Mailbox[Option[Request]]
private val thread = Isabelle_Thread.fork(name = name, daemon = daemon) { main_loop(Nil) }
def is_active: Boolean = active && thread.isAlive
def check_thread: Boolean = Thread.currentThread == thread
private def failure(exn: Throwable): Unit =
Output.error_message(
"Consumer thread failure: " + quote(thread.getName) + "\n" + Exn.message(exn))
private def robust_finish(): Unit =
try { finish() } catch { case exn: Throwable => failure(exn) }
/* requests */
private class Request(val arg: A, acknowledge: Boolean = false)
{
val ack: Option[Synchronized[Option[Exn.Result[Unit]]]] =
if (acknowledge) Some(Synchronized(None)) else None
- def await
+ def await: Unit =
{
for (a <- ack) {
Exn.release(a.guarded_access({ case None => None case res => Some((res.get, res)) }))
}
}
}
- private def request(req: Request)
+ private def request(req: Request): Unit =
{
synchronized {
if (is_active) mailbox.send(Some(req))
else error("Consumer thread not active: " + quote(thread.getName))
}
req.await
}
@tailrec private def main_loop(msgs: List[Option[Request]]): Unit =
msgs match {
case Nil => main_loop(mailbox.receive())
case None :: _ => robust_finish()
case _ =>
val reqs =
proper_list(msgs.takeWhile(msg => msg.isDefined && bulk(msg.get.arg)))
.getOrElse(msgs.take(1))
.map(_.get)
val (results, continue) = consume(reqs.map(_.arg))
for { (Some(req), Some(res)) <- reqs.map(Some(_)).zipAll(results.map(Some(_)), None, None) }
{
(req.ack, res) match {
case ((Some(a), _)) => a.change(_ => Some(res))
case ((None, Exn.Res(_))) =>
case ((None, Exn.Exn(exn))) => failure(exn)
}
}
if (continue) main_loop(msgs.drop(reqs.length))
else robust_finish()
}
/* main methods */
assert(is_active)
- def send(arg: A) { request(new Request(arg)) }
- def send_wait(arg: A) { request(new Request(arg, acknowledge = true)) }
+ def send(arg: A): Unit = request(new Request(arg))
+ def send_wait(arg: A): Unit = request(new Request(arg, acknowledge = true))
- def shutdown()
+ def shutdown(): Unit =
{
synchronized { if (is_active) { active = false; mailbox.send(None) } }
thread.join
}
}
diff --git a/src/Pure/Concurrent/event_timer.scala b/src/Pure/Concurrent/event_timer.scala
--- a/src/Pure/Concurrent/event_timer.scala
+++ b/src/Pure/Concurrent/event_timer.scala
@@ -1,34 +1,34 @@
/* Title: Pure/Concurrent/event_timer.scala
Author: Makarius
Initiate event after given point in time.
Note: events are run as synchronized action within a dedicated thread
and should finish quickly without further ado.
*/
package isabelle
import java.util.{Timer, TimerTask, Date => JDate}
object Event_Timer
{
private lazy val event_timer = new Timer("event_timer", true)
final class Request private[Event_Timer](val time: Time, val repeat: Option[Time], task: TimerTask)
{
def cancel: Boolean = task.cancel
}
def request(time: Time, repeat: Option[Time] = None)(event: => Unit): Request =
{
- val task = new TimerTask { def run { event } }
+ val task = new TimerTask { def run: Unit = event }
repeat match {
case None => event_timer.schedule(task, new JDate(time.ms))
case Some(rep) => event_timer.schedule(task, new JDate(time.ms), rep.ms)
}
new Request(time, repeat, task)
}
}
diff --git a/src/Pure/Concurrent/future.scala b/src/Pure/Concurrent/future.scala
--- a/src/Pure/Concurrent/future.scala
+++ b/src/Pure/Concurrent/future.scala
@@ -1,161 +1,161 @@
/* Title: Pure/Concurrent/future.scala
Author: Makarius
Value-oriented parallel execution via futures and promises.
*/
package isabelle
import java.util.concurrent.Callable
/* futures and promises */
object Future
{
def value[A](x: A): Future[A] = new Value_Future(x)
def fork[A](body: => A): Future[A] = new Task_Future[A](body)
def promise[A]: Promise[A] = new Promise_Future[A]
def thread[A](
name: String = "",
group: ThreadGroup = Isabelle_Thread.current_thread_group,
pri: Int = Thread.NORM_PRIORITY,
daemon: Boolean = false,
inherit_locals: Boolean = false,
uninterruptible: Boolean = false)(body: => A): Future[A] =
{
new Thread_Future[A](name, group, pri, daemon, inherit_locals, uninterruptible, body)
}
}
trait Future[A]
{
def peek: Option[Exn.Result[A]]
def is_finished: Boolean = peek.isDefined
def get_finished: A = { require(is_finished, "future not finished"); Exn.release(peek.get) }
def join_result: Exn.Result[A]
def join: A = Exn.release(join_result)
def map[B](f: A => B): Future[B] = Future.fork { f(join) }
def cancel: Unit
override def toString: String =
peek match {
case None => ""
case Some(Exn.Exn(_)) => ""
case Some(Exn.Res(x)) => x.toString
}
}
trait Promise[A] extends Future[A]
{
def fulfill_result(res: Exn.Result[A]): Unit
def fulfill(x: A): Unit
}
/* value future */
private class Value_Future[A](x: A) extends Future[A]
{
val peek: Option[Exn.Result[A]] = Some(Exn.Res(x))
def join_result: Exn.Result[A] = peek.get
- def cancel {}
+ def cancel: Unit = {}
}
/* task future via thread pool */
private class Task_Future[A](body: => A) extends Future[A]
{
private sealed abstract class Status
private case object Ready extends Status
private case class Running(thread: Thread) extends Status
private case object Terminated extends Status
private case class Finished(result: Exn.Result[A]) extends Status
private val status = Synchronized[Status](Ready)
def peek: Option[Exn.Result[A]] =
status.value match {
case Finished(result) => Some(result)
case _ => None
}
- private def try_run()
+ private def try_run(): Unit =
{
val do_run =
status.change_result {
case Ready => (true, Running(Thread.currentThread))
case st => (false, st)
}
if (do_run) {
val result = Exn.capture(body)
status.change(_ => Terminated)
status.change(_ => Finished(if (Thread.interrupted) Exn.Exn(Exn.Interrupt()) else result))
}
}
private val task = Isabelle_Thread.pool.submit(new Callable[Unit] { def call = try_run() })
def join_result: Exn.Result[A] =
{
try_run()
status.guarded_access {
case st @ Finished(result) => Some((result, st))
case _ => None
}
}
def cancel =
{
status.change {
case Ready => task.cancel(false); Finished(Exn.Exn(Exn.Interrupt()))
case st @ Running(thread) => thread.interrupt; st
case st => st
}
}
}
/* promise future */
private class Promise_Future[A] extends Promise[A]
{
private val state = Synchronized[Option[Exn.Result[A]]](None)
def peek: Option[Exn.Result[A]] = state.value
def join_result: Exn.Result[A] =
state.guarded_access(st => if (st.isEmpty) None else Some((st.get, st)))
def fulfill_result(result: Exn.Result[A]): Unit =
state.change(st => if (st.isEmpty) Some(result) else throw new IllegalStateException)
def fulfill(x: A): Unit = fulfill_result(Exn.Res(x))
def cancel: Unit =
state.change(st => if (st.isEmpty) Some(Exn.Exn(Exn.Interrupt())) else st)
}
/* thread future */
private class Thread_Future[A](
name: String,
group: ThreadGroup,
pri: Int,
daemon: Boolean,
inherit_locals: Boolean,
uninterruptible: Boolean,
body: => A) extends Future[A]
{
private val result = Future.promise[A]
private val thread =
Isabelle_Thread.fork(name = name, group = group, pri = pri, daemon = daemon,
inherit_locals = inherit_locals, uninterruptible = uninterruptible)
{ result.fulfill_result(Exn.capture(body)) }
def peek: Option[Exn.Result[A]] = result.peek
def join_result: Exn.Result[A] = result.join_result
def cancel: Unit = thread.interrupt
}
diff --git a/src/Pure/Concurrent/isabelle_thread.scala b/src/Pure/Concurrent/isabelle_thread.scala
--- a/src/Pure/Concurrent/isabelle_thread.scala
+++ b/src/Pure/Concurrent/isabelle_thread.scala
@@ -1,195 +1,195 @@
/* Title: Pure/Concurrent/isabelle_thread.scala
Author: Makarius
Isabelle-specific thread management.
*/
package isabelle
import java.util.concurrent.{ThreadPoolExecutor, TimeUnit, LinkedBlockingQueue}
object Isabelle_Thread
{
/* self-thread */
def self: Isabelle_Thread =
Thread.currentThread match {
case thread: Isabelle_Thread => thread
case thread => error("Isabelle-specific thread required: " + thread)
}
def check_self: Boolean =
Thread.currentThread.isInstanceOf[Isabelle_Thread]
/* create threads */
private val counter = Counter.make()
def make_name(name: String = "", base: String = "thread"): String =
{
val prefix = "Isabelle."
val suffix = if (name.nonEmpty) name else base + counter()
if (suffix.startsWith(prefix)) suffix else prefix + suffix
}
def current_thread_group: ThreadGroup = Thread.currentThread.getThreadGroup
lazy val worker_thread_group: ThreadGroup =
new ThreadGroup(current_thread_group, "Isabelle worker")
def create(
main: Runnable,
name: String = "",
group: ThreadGroup = current_thread_group,
pri: Int = Thread.NORM_PRIORITY,
daemon: Boolean = false,
inherit_locals: Boolean = false): Isabelle_Thread =
{
new Isabelle_Thread(main, name = make_name(name = name), group = group,
pri = pri, daemon = daemon, inherit_locals = inherit_locals)
}
def fork(
name: String = "",
group: ThreadGroup = current_thread_group,
pri: Int = Thread.NORM_PRIORITY,
daemon: Boolean = false,
inherit_locals: Boolean = false,
uninterruptible: Boolean = false)(body: => Unit): Isabelle_Thread =
{
val main: Runnable =
if (uninterruptible) { () => Isabelle_Thread.uninterruptible { body } }
else { () => body }
val thread =
create(main, name = name, group = group, pri = pri,
daemon = daemon, inherit_locals = inherit_locals)
thread.start
thread
}
/* thread pool */
def max_threads(): Int =
{
val m = Value.Int.unapply(System.getProperty("isabelle.threads", "0")) getOrElse 0
if (m > 0) m else (Runtime.getRuntime.availableProcessors max 1) min 8
}
lazy val pool: ThreadPoolExecutor =
{
val n = max_threads()
val executor =
new ThreadPoolExecutor(n, n, 2500L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue[Runnable])
executor.setThreadFactory(
create(_, name = make_name(base = "worker"), group = worker_thread_group))
executor
}
/* interrupt handlers */
object Interrupt_Handler
{
def apply(handle: Isabelle_Thread => Unit, name: String = "handler"): Interrupt_Handler =
new Interrupt_Handler(handle, name)
val interruptible: Interrupt_Handler =
Interrupt_Handler(_.raise_interrupt, name = "interruptible")
val uninterruptible: Interrupt_Handler =
Interrupt_Handler(_.postpone_interrupt, name = "uninterruptible")
}
class Interrupt_Handler private(handle: Isabelle_Thread => Unit, name: String)
extends Function[Isabelle_Thread, Unit]
{
- def apply(thread: Isabelle_Thread) { handle(thread) }
+ def apply(thread: Isabelle_Thread): Unit = handle(thread)
override def toString: String = name
}
def interrupt_handler[A](handler: Interrupt_Handler)(body: => A): A =
if (handler == null) body
else self.interrupt_handler(handler)(body)
def interrupt_handler[A](handle: Isabelle_Thread => Unit)(body: => A): A =
self.interrupt_handler(Interrupt_Handler(handle))(body)
def interruptible[A](body: => A): A =
interrupt_handler(Interrupt_Handler.interruptible)(body)
def uninterruptible[A](body: => A): A =
interrupt_handler(Interrupt_Handler.uninterruptible)(body)
def try_uninterruptible[A](body: => A): A =
if (check_self) interrupt_handler(Interrupt_Handler.uninterruptible)(body)
else body
}
class Isabelle_Thread private(main: Runnable, name: String, group: ThreadGroup,
pri: Int, daemon: Boolean, inherit_locals: Boolean)
extends Thread(group, null, name, 0L, inherit_locals)
{
thread =>
thread.setPriority(pri)
thread.setDaemon(daemon)
- override def run { main.run() }
+ override def run: Unit = main.run()
def is_self: Boolean = Thread.currentThread == thread
/* interrupt state */
// synchronized, with concurrent changes
private var interrupt_postponed: Boolean = false
def clear_interrupt: Boolean = synchronized
{
val was_interrupted = isInterrupted || interrupt_postponed
Exn.Interrupt.dispose()
interrupt_postponed = false
was_interrupted
}
def raise_interrupt: Unit = synchronized
{
interrupt_postponed = false
super.interrupt()
}
def postpone_interrupt: Unit = synchronized
{
interrupt_postponed = true
Exn.Interrupt.dispose()
}
/* interrupt handler */
// non-synchronized, only changed on self-thread
@volatile private var handler = Isabelle_Thread.Interrupt_Handler.interruptible
override def interrupt: Unit = handler(thread)
def interrupt_handler[A](new_handler: Isabelle_Thread.Interrupt_Handler)(body: => A): A =
if (new_handler == null) body
else {
require(is_self, "interrupt handler on other thread")
val old_handler = handler
handler = new_handler
try {
if (clear_interrupt) interrupt
body
}
finally {
handler = old_handler
if (clear_interrupt) interrupt
}
}
}
diff --git a/src/Pure/GUI/gui.scala b/src/Pure/GUI/gui.scala
--- a/src/Pure/GUI/gui.scala
+++ b/src/Pure/GUI/gui.scala
@@ -1,355 +1,356 @@
/* Title: Pure/GUI/gui.scala
Author: Makarius
Basic GUI tools (for AWT/Swing).
*/
package isabelle
import java.awt.{Component, Container, Font, Image, Insets, KeyboardFocusManager, Window, Point,
Rectangle, Dimension, GraphicsEnvironment, MouseInfo, Toolkit}
import java.awt.font.{FontRenderContext, LineMetrics, TextAttribute, TransformAttribute}
import java.awt.geom.AffineTransform
import javax.swing.{ImageIcon, JButton, JDialog, JFrame, JLabel, JLayeredPane, JOptionPane,
JTextField, JWindow, LookAndFeel, UIManager, SwingUtilities}
import scala.swing.{ComboBox, ScrollPane, TextArea}
import scala.swing.event.SelectionChanged
object GUI
{
/* Swing look-and-feel */
def init_laf(): Unit = com.formdev.flatlaf.FlatLightLaf.install()
def current_laf(): String = UIManager.getLookAndFeel.getClass.getName()
def is_macos_laf(): Boolean =
Platform.is_macos && UIManager.getSystemLookAndFeelClassName() == current_laf()
class Look_And_Feel(laf: LookAndFeel) extends Isabelle_System.Service
{
def info: UIManager.LookAndFeelInfo =
new UIManager.LookAndFeelInfo(laf.getName, laf.getClass.getName)
}
lazy val look_and_feels: List[Look_And_Feel] =
Isabelle_System.make_services(classOf[Look_And_Feel])
- def init_lafs()
+ def init_lafs(): Unit =
{
val old_lafs =
Set(
"com.sun.java.swing.plaf.motif.MotifLookAndFeel",
"com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel")
val lafs =
UIManager.getInstalledLookAndFeels().toList
.filterNot(info => old_lafs(info.getClassName))
val more_lafs = look_and_feels.map(_.info)
UIManager.setInstalledLookAndFeels((more_lafs ::: lafs).toArray)
}
/* additional look-and-feels */
/* plain focus traversal, notably for text fields */
- def plain_focus_traversal(component: Component)
+ def plain_focus_traversal(component: Component): Unit =
{
val dummy_button = new JButton
def apply(id: Int): Unit =
component.setFocusTraversalKeys(id, dummy_button.getFocusTraversalKeys(id))
apply(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS)
apply(KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS)
}
/* simple dialogs */
def scrollable_text(raw_txt: String, width: Int = 60, height: Int = 20, editable: Boolean = false)
: ScrollPane =
{
val txt = Output.clean_yxml(raw_txt)
val text = new TextArea(txt)
if (width > 0) text.columns = width
if (height > 0 && split_lines(txt).length > height) text.rows = height
text.editable = editable
new ScrollPane(text)
}
private def simple_dialog(kind: Int, default_title: String,
- parent: Component, title: String, message: Iterable[Any])
+ parent: Component, title: String, message: Iterable[Any]): Unit =
{
GUI_Thread.now {
val java_message =
message.iterator.map({ case x: scala.swing.Component => x.peer case x => x }).
toArray.asInstanceOf[Array[AnyRef]]
JOptionPane.showMessageDialog(parent, java_message,
if (title == null) default_title else title, kind)
}
}
def dialog(parent: Component, title: String, message: Any*): Unit =
simple_dialog(JOptionPane.PLAIN_MESSAGE, null, parent, title, message)
def warning_dialog(parent: Component, title: String, message: Any*): Unit =
simple_dialog(JOptionPane.WARNING_MESSAGE, "Warning", parent, title, message)
def error_dialog(parent: Component, title: String, message: Any*): Unit =
simple_dialog(JOptionPane.ERROR_MESSAGE, "Error", parent, title, message)
def confirm_dialog(parent: Component, title: String, option_type: Int, message: Any*): Int =
GUI_Thread.now {
val java_message = message map { case x: scala.swing.Component => x.peer case x => x }
JOptionPane.showConfirmDialog(parent,
java_message.toArray.asInstanceOf[Array[AnyRef]], title,
option_type, JOptionPane.QUESTION_MESSAGE)
}
/* zoom box */
private val Zoom_Factor = "([0-9]+)%?".r
abstract class Zoom_Box extends ComboBox[String](
List("50%", "70%", "85%", "100%", "125%", "150%", "175%", "200%", "300%", "400%"))
{
def changed: Unit
def factor: Int = parse(selection.item)
private def parse(text: String): Int =
text match {
case Zoom_Factor(s) =>
val i = Integer.parseInt(s)
if (10 <= i && i < 1000) i else 100
case _ => 100
}
private def print(i: Int): String = i.toString + "%"
- def set_item(i: Int) {
+ def set_item(i: Int): Unit =
+ {
peer.getEditor match {
case null =>
case editor => editor.setItem(print(i))
}
}
makeEditable()(c => new ComboBox.BuiltInEditor(c)(text => print(parse(text)), x => x))
peer.getEditor.getEditorComponent match {
case text: JTextField => text.setColumns(4)
case _ =>
}
selection.index = 3
listenTo(selection)
reactions += { case SelectionChanged(_) => changed }
}
/* tooltip with multi-line support */
def tooltip_lines(text: String): String =
if (text == null || text == "") null
else "" + HTML.output(text) + ""
/* icon */
def isabelle_icon(): ImageIcon =
new ImageIcon(getClass.getClassLoader.getResource("isabelle/isabelle_transparent-32.gif"))
def isabelle_icons(): List[ImageIcon] =
for (icon <- List("isabelle/isabelle_transparent-32.gif", "isabelle/isabelle_transparent.gif"))
yield new ImageIcon(getClass.getClassLoader.getResource(icon))
def isabelle_image(): Image = isabelle_icon().getImage
/* location within multi-screen environment */
final case class Screen_Location(point: Point, bounds: Rectangle)
{
def relative(parent: Component, size: Dimension): Point =
{
val w = size.width
val h = size.height
val x0 = parent.getLocationOnScreen.x
val y0 = parent.getLocationOnScreen.y
val x1 = x0 + parent.getWidth - w
val y1 = y0 + parent.getHeight - h
val x2 = point.x min (bounds.x + bounds.width - w)
val y2 = point.y min (bounds.y + bounds.height - h)
val location = new Point((x2 min x1) max x0, (y2 min y1) max y0)
SwingUtilities.convertPointFromScreen(location, parent)
location
}
}
def screen_location(component: Component, point: Point): Screen_Location =
{
val screen_point = new Point(point.x, point.y)
if (component != null) SwingUtilities.convertPointToScreen(screen_point, component)
val ge = GraphicsEnvironment.getLocalGraphicsEnvironment
val screen_bounds =
(for {
device <- ge.getScreenDevices.iterator
config <- device.getConfigurations.iterator
bounds = config.getBounds
} yield bounds).find(_.contains(screen_point)) getOrElse ge.getMaximumWindowBounds
Screen_Location(screen_point, screen_bounds)
}
def mouse_location(): Screen_Location =
screen_location(null, MouseInfo.getPointerInfo.getLocation)
/* screen size */
sealed case class Screen_Size(bounds: Rectangle, insets: Insets)
{
def full_screen_bounds: Rectangle =
if (Platform.is_linux) {
// avoid menu bar and docking areas
new Rectangle(
bounds.x + insets.left,
bounds.y + insets.top,
bounds.width - insets.left - insets.right,
bounds.height - insets.top - insets.bottom)
}
else if (Platform.is_macos) {
// avoid menu bar, but ignore docking areas
new Rectangle(
bounds.x,
bounds.y + insets.top,
bounds.width,
bounds.height - insets.top)
}
else bounds
}
def screen_size(component: Component): Screen_Size =
{
val config = component.getGraphicsConfiguration
val bounds = config.getBounds
val insets = Toolkit.getDefaultToolkit.getScreenInsets(config)
Screen_Size(bounds, insets)
}
/* component hierachy */
def get_parent(component: Component): Option[Container] =
component.getParent match {
case null => None
case parent => Some(parent)
}
def ancestors(component: Component): Iterator[Container] = new Iterator[Container] {
private var next_elem = get_parent(component)
def hasNext: Boolean = next_elem.isDefined
def next(): Container =
next_elem match {
case Some(parent) =>
next_elem = get_parent(parent)
parent
case None => Iterator.empty.next()
}
}
def parent_window(component: Component): Option[Window] =
ancestors(component).collectFirst({ case x: Window => x })
def layered_pane(component: Component): Option[JLayeredPane] =
parent_window(component) match {
case Some(w: JWindow) => Some(w.getLayeredPane)
case Some(w: JFrame) => Some(w.getLayeredPane)
case Some(w: JDialog) => Some(w.getLayeredPane)
case _ => None
}
- def traverse_components(component: Component, apply: Component => Unit)
+ def traverse_components(component: Component, apply: Component => Unit): Unit =
{
- def traverse(comp: Component)
+ def traverse(comp: Component): Unit =
{
apply(comp)
comp match {
case cont: Container =>
for (i <- 0 until cont.getComponentCount)
traverse(cont.getComponent(i))
case _ =>
}
}
traverse(component)
}
/* font operations */
def copy_font(font: Font): Font =
if (font == null) null
else new Font(font.getFamily, font.getStyle, font.getSize)
def line_metrics(font: Font): LineMetrics =
font.getLineMetrics("", new FontRenderContext(null, false, false))
def transform_font(font: Font, transform: AffineTransform): Font =
font.deriveFont(java.util.Map.of(TextAttribute.TRANSFORM, new TransformAttribute(transform)))
def font(family: String = Isabelle_Fonts.sans, size: Int = 1, bold: Boolean = false): Font =
new Font(family, if (bold) Font.BOLD else Font.PLAIN, size)
def label_font(): Font = (new JLabel).getFont
/* Isabelle fonts */
def imitate_font(font: Font,
family: String = Isabelle_Fonts.sans,
scale: Double = 1.0): Font =
{
val font1 = new Font(family, font.getStyle, font.getSize)
val rel_size = line_metrics(font).getHeight.toDouble / line_metrics(font1).getHeight
new Font(family, font.getStyle, (scale * rel_size * font.getSize).toInt)
}
def imitate_font_css(font: Font,
family: String = Isabelle_Fonts.sans,
scale: Double = 1.0): String =
{
val font1 = new Font(family, font.getStyle, font.getSize)
val rel_size = line_metrics(font).getHeight.toDouble / line_metrics(font1).getHeight
"font-family: " + family + "; font-size: " + (scale * rel_size * 100).toInt + "%;"
}
- def use_isabelle_fonts()
+ def use_isabelle_fonts(): Unit =
{
val default_font = label_font()
val ui = UIManager.getDefaults
for (prop <- List(
"ToggleButton.font",
"CheckBoxMenuItem.font",
"Label.font",
"Menu.font",
"MenuItem.font",
"PopupMenu.font",
"Table.font",
"TableHeader.font",
"TextArea.font",
"TextField.font",
"TextPane.font",
"ToolTip.font",
"Tree.font"))
{
val font = ui.get(prop) match { case font: Font => font case _ => default_font }
ui.put(prop, GUI.imitate_font(font))
}
}
}
class FlatLightLaf extends GUI.Look_And_Feel(new com.formdev.flatlaf.FlatLightLaf)
class FlatDarkLaf extends GUI.Look_And_Feel(new com.formdev.flatlaf.FlatDarkLaf)
diff --git a/src/Pure/GUI/gui_thread.scala b/src/Pure/GUI/gui_thread.scala
--- a/src/Pure/GUI/gui_thread.scala
+++ b/src/Pure/GUI/gui_thread.scala
@@ -1,57 +1,57 @@
/* Title: Pure/GUI/gui_thread.scala
Author: Makarius
Evaluation within the GUI thread (for AWT/Swing).
*/
package isabelle
import javax.swing.SwingUtilities
object GUI_Thread
{
/* context check */
def assert[A](body: => A): A =
{
Predef.assert(SwingUtilities.isEventDispatchThread)
body
}
def require[A](body: => A): A =
{
Predef.require(SwingUtilities.isEventDispatchThread, "GUI thread expected")
body
}
/* event dispatch queue */
def now[A](body: => A): A =
{
if (SwingUtilities.isEventDispatchThread) body
else {
lazy val result = assert { Exn.capture(body) }
SwingUtilities.invokeAndWait(() => result)
Exn.release(result)
}
}
- def later(body: => Unit)
+ def later(body: => Unit): Unit =
{
if (SwingUtilities.isEventDispatchThread) body
else SwingUtilities.invokeLater(() => body)
}
def future[A](body: => A): Future[A] =
{
if (SwingUtilities.isEventDispatchThread) Future.value(body)
else {
val promise = Future.promise[A]
later { promise.fulfill_result(Exn.capture(body)) }
promise
}
}
}
diff --git a/src/Pure/GUI/popup.scala b/src/Pure/GUI/popup.scala
--- a/src/Pure/GUI/popup.scala
+++ b/src/Pure/GUI/popup.scala
@@ -1,38 +1,38 @@
/* Title: Pure/GUI/popup.scala
Author: Makarius
Popup within layered pane.
*/
package isabelle
import java.awt.{Point, Dimension}
import javax.swing.{JLayeredPane, JComponent}
class Popup(
layered: JLayeredPane,
component: JComponent,
location: Point,
size: Dimension)
{
- def show
+ def show: Unit =
{
component.setLocation(location)
component.setSize(size)
component.setPreferredSize(size)
component.setOpaque(true)
layered.add(component, JLayeredPane.DEFAULT_LAYER)
layered.moveToFront(component)
layered.repaint(component.getBounds())
}
- def hide
+ def hide: Unit =
{
val bounds = component.getBounds()
layered.remove(component)
layered.repaint(bounds)
}
}
diff --git a/src/Pure/GUI/wrap_panel.scala b/src/Pure/GUI/wrap_panel.scala
--- a/src/Pure/GUI/wrap_panel.scala
+++ b/src/Pure/GUI/wrap_panel.scala
@@ -1,124 +1,124 @@
/* Title: Pure/GUI/wrap_panel.scala
Author: Makarius
Panel with improved FlowLayout for wrapping of components over
multiple lines, see also
https://tips4java.wordpress.com/2008/11/06/wrap-layout/ and
scala.swing.FlowPanel.
*/
package isabelle
import java.awt.{FlowLayout, Container, Dimension}
import javax.swing.{JComponent, JPanel, JScrollPane}
import scala.swing.{Panel, FlowPanel, Component, SequentialContainer, ScrollPane}
object Wrap_Panel
{
val Alignment = FlowPanel.Alignment
class Layout(align: Int = FlowLayout.CENTER, hgap: Int = 5, vgap: Int = 5)
extends FlowLayout(align: Int, hgap: Int, vgap: Int)
{
override def preferredLayoutSize(target: Container): Dimension =
layout_size(target, true)
override def minimumLayoutSize(target: Container): Dimension =
{
val minimum = layout_size(target, false)
minimum.width -= (getHgap + 1)
minimum
}
private def layout_size(target: Container, preferred: Boolean): Dimension =
{
target.getTreeLock.synchronized
{
val target_width =
if (target.getSize.width == 0) Integer.MAX_VALUE
else target.getSize.width
val hgap = getHgap
val vgap = getVgap
val insets = target.getInsets
val horizontal_insets_and_gap = insets.left + insets.right + (hgap * 2)
val max_width = target_width - horizontal_insets_and_gap
/* fit components into rows */
val dim = new Dimension(0, 0)
var row_width = 0
var row_height = 0
- def add_row()
+ def add_row(): Unit =
{
dim.width = dim.width max row_width
if (dim.height > 0) dim.height += vgap
dim.height += row_height
}
for {
i <- (0 until target.getComponentCount).iterator
m = target.getComponent(i)
if m.isVisible
d = if (preferred) m.getPreferredSize else m.getMinimumSize()
}
{
if (row_width + d.width > max_width) {
add_row()
row_width = 0
row_height = 0
}
if (row_width != 0) row_width += hgap
row_width += d.width
row_height = row_height max d.height
}
add_row()
dim.width += horizontal_insets_and_gap
dim.height += insets.top + insets.bottom + vgap * 2
/* special treatment for ScrollPane */
val scroll_pane =
GUI.ancestors(target).exists(
{
case _: JScrollPane => true
case c: JComponent if Component.wrap(c).isInstanceOf[ScrollPane] => true
case _ => false
})
if (scroll_pane && target.isValid)
dim.width -= (hgap + 1)
dim
}
}
}
def apply(contents: List[Component] = Nil,
alignment: Alignment.Value = Alignment.Right): Wrap_Panel =
new Wrap_Panel(contents, alignment)
}
class Wrap_Panel(contents0: List[Component] = Nil,
alignment: Wrap_Panel.Alignment.Value = Wrap_Panel.Alignment.Right)
extends Panel with SequentialContainer.Wrapper
{
override lazy val peer: JPanel =
new JPanel(new Wrap_Panel.Layout(alignment.id)) with SuperMixin
contents ++= contents0
private def layoutManager = peer.getLayout.asInstanceOf[Wrap_Panel.Layout]
def vGap: Int = layoutManager.getVgap
- def vGap_=(n: Int) { layoutManager.setVgap(n) }
+ def vGap_=(n: Int): Unit = layoutManager.setVgap(n)
def hGap: Int = layoutManager.getHgap
- def hGap_=(n: Int) { layoutManager.setHgap(n) }
+ def hGap_=(n: Int): Unit = layoutManager.setHgap(n)
}
diff --git a/src/Pure/General/completion.scala b/src/Pure/General/completion.scala
--- a/src/Pure/General/completion.scala
+++ b/src/Pure/General/completion.scala
@@ -1,516 +1,516 @@
/* Title: Pure/General/completion.scala
Author: Makarius
Semantic completion within the formal context (reported names).
Syntactic completion of keywords and symbols, with abbreviations
(based on language context).
*/
package isabelle
import scala.collection.immutable.SortedMap
import scala.util.parsing.combinator.RegexParsers
import scala.util.matching.Regex
import scala.math.Ordering
object Completion
{
/** completion result **/
sealed case class Item(
range: Text.Range,
original: String,
name: String,
description: List[String],
replacement: String,
move: Int,
immediate: Boolean)
object Result
{
def empty(range: Text.Range): Result = Result(range, "", false, Nil)
def merge(history: History, results: Option[Result]*): Option[Result] =
((None: Option[Result]) /: results)({
case (result1, None) => result1
case (None, result2) => result2
case (result1 @ Some(res1), Some(res2)) =>
if (res1.range != res2.range || res1.original != res2.original) result1
else {
val items = (res1.items ::: res2.items).sorted(history.ordering)
Some(Result(res1.range, res1.original, false, items))
}
})
}
sealed case class Result(
range: Text.Range,
original: String,
unique: Boolean,
items: List[Item])
/** persistent history **/
private val COMPLETION_HISTORY = Path.explode("$ISABELLE_HOME_USER/etc/completion_history")
object History
{
val empty: History = new History()
def load(): History =
{
def ignore_error(msg: String): Unit =
Output.warning("Ignoring bad content of file " + COMPLETION_HISTORY +
(if (msg == "") "" else "\n" + msg))
val content =
if (COMPLETION_HISTORY.is_file) {
try {
import XML.Decode._
list(pair(string, int))(Symbol.decode_yxml(File.read(COMPLETION_HISTORY)))
}
catch {
case ERROR(msg) => ignore_error(msg); Nil
case _: XML.Error => ignore_error(""); Nil
}
}
else Nil
(empty /: content)(_ + _)
}
}
final class History private(rep: SortedMap[String, Int] = SortedMap.empty)
{
override def toString: String = rep.mkString("Completion.History(", ",", ")")
def frequency(name: String): Int =
default_frequency(Symbol.encode(name)) getOrElse
rep.getOrElse(name, 0)
def + (entry: (String, Int)): History =
{
val (name, freq) = entry
if (name == "") this
else new History(rep + (name -> (frequency(name) + freq)))
}
def ordering: Ordering[Item] =
new Ordering[Item] {
def compare(item1: Item, item2: Item): Int =
frequency(item2.name) compare frequency(item1.name)
}
- def save()
+ def save(): Unit =
{
Isabelle_System.make_directory(COMPLETION_HISTORY.dir)
File.write_backup(COMPLETION_HISTORY,
{
import XML.Encode._
Symbol.encode_yxml(list(pair(string, int))(rep.toList))
})
}
}
class History_Variable
{
private var history = History.empty
def value: History = synchronized { history }
- def load()
+ def load(): Unit =
{
val h = History.load()
synchronized { history = h }
}
def update(item: Item, freq: Int = 1): Unit = synchronized {
history = history + (item.name -> freq)
}
}
/** semantic completion **/
def clean_name(s: String): Option[String] =
if (s == "" || s == "_") None
else Some(s.reverseIterator.dropWhile(_ == '_').toList.reverse.mkString)
def completed(input: String): String => Boolean =
clean_name(input) match {
case None => (name: String) => false
case Some(prefix) => (name: String) => name.startsWith(prefix)
}
def report_no_completion(pos: Position.T): String =
YXML.string_of_tree(Semantic.Info(pos, No_Completion))
def report_names(pos: Position.T, names: List[(String, (String, String))], total: Int = 0): String =
if (names.isEmpty) ""
else
YXML.string_of_tree(Semantic.Info(pos, Names(if (total > 0) total else names.length, names)))
def report_theories(pos: Position.T, thys: List[String], total: Int = 0): String =
report_names(pos, thys.map(name => (name, (Markup.THEORY, name))), total)
object Semantic
{
object Info
{
def apply(pos: Position.T, semantic: Semantic): XML.Elem =
{
val elem =
semantic match {
case No_Completion => XML.Elem(Markup(Markup.NO_COMPLETION, pos), Nil)
case Names(total, names) =>
XML.Elem(Markup(Markup.COMPLETION, pos),
{
import XML.Encode._
pair(int, list(pair(string, pair(string, string))))(total, names)
})
}
XML.Elem(Markup(Markup.REPORT, pos), List(elem))
}
def unapply(info: Text.Markup): Option[Text.Info[Semantic]] =
info.info match {
case XML.Elem(Markup(Markup.COMPLETION, _), body) =>
try {
val (total, names) =
{
import XML.Decode._
pair(int, list(pair(string, pair(string, string))))(body)
}
Some(Text.Info(info.range, Names(total, names)))
}
catch { case _: XML.Error => None }
case XML.Elem(Markup(Markup.NO_COMPLETION, _), _) =>
Some(Text.Info(info.range, No_Completion))
case _ => None
}
}
}
sealed abstract class Semantic
case object No_Completion extends Semantic
case class Names(total: Int, names: List[(String, (String, String))]) extends Semantic
{
def complete(
range: Text.Range,
history: Completion.History,
unicode: Boolean,
original: String): Option[Completion.Result] =
{
def decode(s: String): String = if (unicode) Symbol.decode(s) else s
val items =
for {
(xname, (kind, name)) <- names
xname1 = decode(xname)
if xname1 != original
(full_name, descr_name) =
if (kind == "") (name, quote(decode(name)))
else
(Long_Name.qualify(kind, name),
Word.implode(Word.explode('_', kind)) +
(if (xname == name) "" else " " + quote(decode(name))))
} yield {
val description = List(xname1, "(" + descr_name + ")")
val replacement =
List(original, xname1).map(Token.explode(Keyword.Keywords.empty, _)) match {
case List(List(tok), _) if tok.kind == Token.Kind.CARTOUCHE =>
Symbol.cartouche_decoded(xname1)
case List(_, List(tok)) if tok.is_name => xname1
case _ => quote(xname1)
}
Item(range, original, full_name, description, replacement, 0, true)
}
if (items.isEmpty) None
else Some(Result(range, original, names.length == 1, items.sorted(history.ordering)))
}
}
/** syntactic completion **/
/* language context */
object Language_Context
{
val outer = Language_Context("", true, false)
val inner = Language_Context(Markup.Language.UNKNOWN, true, false)
val ML_outer = Language_Context(Markup.Language.ML, false, true)
val ML_inner = Language_Context(Markup.Language.ML, true, false)
val SML_outer = Language_Context(Markup.Language.SML, false, false)
}
sealed case class Language_Context(language: String, symbols: Boolean, antiquotes: Boolean)
{
def is_outer: Boolean = language == ""
}
/* make */
val empty: Completion = new Completion()
def make(keywords: List[String], abbrevs: List[(String, String)]): Completion =
empty.add_symbols.add_keywords(keywords).add_abbrevs(
Completion.symbol_abbrevs ::: Completion.default_abbrevs ::: abbrevs)
/* word parsers */
object Word_Parsers extends RegexParsers
{
override val whiteSpace = "".r
private val symboloid_regex: Regex = """\\([A-Za-z0-9_']+|<\^?[A-Za-z0-9_']+>?)""".r
def is_symboloid(s: CharSequence): Boolean = symboloid_regex.pattern.matcher(s).matches
private def reverse_symbol: Parser[String] = """>[A-Za-z0-9_']+\^?<\\""".r
private def reverse_symb: Parser[String] = """[A-Za-z0-9_']{2,}\^?<\\""".r
private def reverse_escape: Parser[String] = """[a-zA-Z0-9_']+\\""".r
private val word_regex = "[a-zA-Z0-9_'.]+".r
private def word2: Parser[String] = "[a-zA-Z0-9_'.]{2,}".r
private def underscores: Parser[String] = "_*".r
def is_word(s: CharSequence): Boolean = word_regex.pattern.matcher(s).matches
def is_word_char(c: Char): Boolean = Symbol.is_ascii_letdig(c) || c == '.'
def read_symbol(in: CharSequence): Option[String] =
{
val reverse_in = new Library.Reverse(in)
parse(reverse_symbol ^^ (_.reverse), reverse_in) match {
case Success(result, _) => Some(result)
case _ => None
}
}
def read_word(in: CharSequence): Option[(String, String)] =
{
val reverse_in = new Library.Reverse(in)
val parser =
(reverse_symbol | reverse_symb | reverse_escape) ^^ (x => (x.reverse, "")) |
underscores ~ word2 ~ opt("?") ^^
{ case x ~ y ~ z => (z.getOrElse("") + y.reverse, x) }
parse(parser, reverse_in) match {
case Success(result, _) => Some(result)
case _ => None
}
}
}
/* templates */
val caret_indicator = '\u0007'
def split_template(s: String): (String, String) =
space_explode(caret_indicator, s) match {
case List(s1, s2) => (s1, s2)
case _ => (s, "")
}
/* abbreviations */
private def symbol_abbrevs: Thy_Header.Abbrevs =
for ((sym, abbr) <- Symbol.abbrevs.toList) yield (abbr, sym)
private val antiquote = "@{"
private val default_abbrevs =
List("@{" -> "@{\u0007}",
"`" -> "\\",
"`" -> "\\",
"`" -> "\\\u0007\\",
"\"" -> "\\",
"\"" -> "\\",
"\"" -> "\\\u0007\\")
private def default_frequency(name: String): Option[Int] =
default_abbrevs.iterator.map(_._2).zipWithIndex.find(_._1 == name).map(_._2)
}
final class Completion private(
keywords: Set[String] = Set.empty,
words_lex: Scan.Lexicon = Scan.Lexicon.empty,
words_map: Multi_Map[String, String] = Multi_Map.empty,
abbrevs_lex: Scan.Lexicon = Scan.Lexicon.empty,
abbrevs_map: Multi_Map[String, (String, String)] = Multi_Map.empty)
{
/* keywords */
private def is_symbol(name: String): Boolean = Symbol.names.isDefinedAt(name)
private def is_keyword(name: String): Boolean = !is_symbol(name) && keywords(name)
private def is_keyword_template(name: String, template: Boolean): Boolean =
is_keyword(name) && (words_map.getOrElse(name, name) != name) == template
def add_keyword(keyword: String): Completion =
new Completion(keywords + keyword, words_lex, words_map, abbrevs_lex, abbrevs_map)
def add_keywords(names: List[String]): Completion =
{
val keywords1 = (keywords /: names) { case (ks, k) => if (ks(k)) ks else ks + k }
if (keywords eq keywords1) this
else new Completion(keywords1, words_lex, words_map, abbrevs_lex, abbrevs_map)
}
/* symbols and abbrevs */
def add_symbols: Completion =
{
val words =
Symbol.names.toList.flatMap({ case (sym, (name, argument)) =>
val word = "\\" + name
val seps =
if (argument == Symbol.ARGUMENT_CARTOUCHE) List("")
else if (argument == Symbol.ARGUMENT_SPACE_CARTOUCHE) List(" ")
else Nil
List(sym -> sym, word -> sym) :::
seps.map(sep => word -> (sym + sep + "\\\u0007\\"))
})
new Completion(
keywords,
words_lex ++ words.map(_._1),
words_map ++ words,
abbrevs_lex,
abbrevs_map)
}
def add_abbrevs(abbrevs: List[(String, String)]): Completion =
(this /: abbrevs)(_.add_abbrev(_))
private def add_abbrev(abbrev: (String, String)): Completion =
abbrev match {
case ("", _) => this
case (abbr, text) =>
val rev_abbr = abbr.reverse
val is_word = Completion.Word_Parsers.is_word(abbr)
val (words_lex1, words_map1) =
if (!is_word) (words_lex, words_map)
else if (text != "") (words_lex + abbr, words_map + abbrev)
else (words_lex -- List(abbr), words_map - abbr)
val (abbrevs_lex1, abbrevs_map1) =
if (is_word) (abbrevs_lex, abbrevs_map)
else if (text != "") (abbrevs_lex + rev_abbr, abbrevs_map + (rev_abbr -> abbrev))
else (abbrevs_lex -- List(rev_abbr), abbrevs_map - rev_abbr)
new Completion(keywords, words_lex1, words_map1, abbrevs_lex1, abbrevs_map1)
}
/* complete */
def complete(
history: Completion.History,
unicode: Boolean,
explicit: Boolean,
start: Text.Offset,
text: CharSequence,
caret: Int,
language_context: Completion.Language_Context): Option[Completion.Result] =
{
val length = text.length
val abbrevs_result =
{
val reverse_in = new Library.Reverse(text.subSequence(0, caret))
Scan.Parsers.parse(Scan.Parsers.literal(abbrevs_lex), reverse_in) match {
case Scan.Parsers.Success(reverse_abbr, _) =>
val abbrevs = abbrevs_map.get_list(reverse_abbr)
abbrevs match {
case Nil => None
case (abbr, _) :: _ =>
val ok =
if (abbr == Completion.antiquote) language_context.antiquotes
else language_context.symbols || Completion.default_abbrevs.exists(_._1 == abbr)
if (ok) Some((abbr, abbrevs))
else None
}
case _ => None
}
}
val words_result =
if (abbrevs_result.isDefined) None
else {
val word_context =
caret < length && Completion.Word_Parsers.is_word_char(text.charAt(caret))
val result =
Completion.Word_Parsers.read_symbol(text.subSequence(0, caret)) match {
case Some(symbol) => Some((symbol, ""))
case None => Completion.Word_Parsers.read_word(text.subSequence(0, caret))
}
result.map(
{
case (word, underscores) =>
val complete_words = words_lex.completions(word)
val full_word = word + underscores
val completions =
if (complete_words.contains(full_word) && is_keyword_template(full_word, false)) Nil
else
for {
complete_word <- complete_words
ok =
if (is_keyword(complete_word)) !word_context && language_context.is_outer
else language_context.symbols || Completion.Word_Parsers.is_symboloid(word)
if ok
completion <- words_map.get_list(complete_word)
} yield (complete_word, completion)
(full_word, completions)
})
}
(abbrevs_result orElse words_result) match {
case Some((original, completions)) if completions.nonEmpty =>
val range = Text.Range(- original.length, 0) + caret + start
val immediate =
explicit ||
(!Completion.Word_Parsers.is_word(original) &&
!Completion.Word_Parsers.is_symboloid(original) &&
Character.codePointCount(original, 0, original.length) > 1)
val unique = completions.length == 1
def decode1(s: String): String = if (unicode) Symbol.decode(s) else s
def decode2(s: String): String = if (unicode) s else Symbol.decode(s)
val items =
for {
(complete_word, name0) <- completions
name1 = decode1(name0)
name2 = decode2(name0)
if name1 != original
(s1, s2) = Completion.split_template(name1)
move = - s2.length
description =
if (is_symbol(name0)) {
if (name1 == name2) List(name1)
else List(name1, "(symbol " + quote(name2) + ")")
}
else if (is_keyword_template(complete_word, true))
List(name1, "(template " + quote(complete_word) + ")")
else if (move != 0) List(name1, "(template)")
else if (is_keyword(complete_word)) List(name1, "(keyword)")
else List(name1)
}
yield Completion.Item(range, original, name1, description, s1 + s2, move, immediate)
if (items.isEmpty) None
else
Some(Completion.Result(range, original, unique,
items.sortBy(_.name).sorted(history.ordering)))
case _ => None
}
}
}
diff --git a/src/Pure/General/csv.scala b/src/Pure/General/csv.scala
--- a/src/Pure/General/csv.scala
+++ b/src/Pure/General/csv.scala
@@ -1,33 +1,33 @@
/* Title: Pure/General/csv.scala
Author: Makarius
Support for CSV: RFC 4180.
*/
package isabelle
object CSV
{
def print_field(field: Any): String =
{
val str = field.toString
if (str.exists("\",\r\n".contains(_))) {
(for (c <- str) yield { if (c == '"') "\"\"" else c.toString }).mkString("\"", "", "\"")
}
else str
}
sealed case class Record(fields: Any*)
{
override def toString: String = fields.iterator.map(print_field).mkString(",")
}
sealed case class File(name: String, header: List[String], records: List[Record])
{
override def toString: String = (Record(header:_*) :: records).mkString("\r\n")
def file_name: String = name + ".csv"
- def write(dir: Path) { isabelle.File.write(dir + Path.explode(file_name), toString) }
+ def write(dir: Path): Unit = isabelle.File.write(dir + Path.explode(file_name), toString)
}
}
diff --git a/src/Pure/General/exn.scala b/src/Pure/General/exn.scala
--- a/src/Pure/General/exn.scala
+++ b/src/Pure/General/exn.scala
@@ -1,147 +1,147 @@
/* Title: Pure/General/exn.scala
Author: Makarius
Support for exceptions (arbitrary throwables).
*/
package isabelle
object Exn
{
/* user errors */
class User_Error(message: String) extends RuntimeException(message)
{
override def equals(that: Any): Boolean =
that match {
case other: User_Error => message == other.getMessage
case _ => false
}
override def hashCode: Int = message.hashCode
override def toString: String = "\n" + Output.error_message_text(message)
}
object ERROR
{
def apply(message: String): User_Error = new User_Error(message)
def unapply(exn: Throwable): Option[String] = user_message(exn)
}
def error(message: String): Nothing = throw ERROR(message)
def cat_message(msgs: String*): String =
cat_lines(msgs.iterator.filterNot(_ == ""))
def cat_error(msgs: String*): Nothing =
error(cat_message(msgs:_*))
/* exceptions as values */
sealed abstract class Result[A]
{
def user_error: Result[A] =
this match {
case Exn(ERROR(msg)) => Exn(ERROR(msg))
case _ => this
}
def map[B](f: A => B): Result[B] =
this match {
case Res(res) => Res(f(res))
case Exn(exn) => Exn(exn)
}
}
case class Res[A](res: A) extends Result[A]
case class Exn[A](exn: Throwable) extends Result[A]
def capture[A](e: => A): Result[A] =
try { Res(e) }
catch { case exn: Throwable => Exn[A](exn) }
def release[A](result: Result[A]): A =
result match {
case Res(x) => x
case Exn(exn) => throw exn
}
def release_first[A](results: List[Result[A]]): List[A] =
results.find({ case Exn(exn) => !is_interrupt(exn) case _ => false }) match {
case Some(Exn(exn)) => throw exn
case _ => results.map(release)
}
/* interrupts */
def is_interrupt(exn: Throwable): Boolean =
{
var found_interrupt = false
var e = exn
while (!found_interrupt && e != null) {
found_interrupt |= e.isInstanceOf[InterruptedException]
e = e.getCause
}
found_interrupt
}
def interruptible_capture[A](e: => A): Result[A] =
try { Res(e) }
catch { case exn: Throwable if !is_interrupt(exn) => Exn[A](exn) }
object Interrupt
{
object ERROR
{
def unapply(exn: Throwable): Option[String] =
if (is_interrupt(exn)) Some(message(exn)) else user_message(exn)
}
def apply(): Throwable = new InterruptedException("Interrupt")
def unapply(exn: Throwable): Boolean = is_interrupt(exn)
- def dispose() { Thread.interrupted }
- def expose() { if (Thread.interrupted) throw apply() }
- def impose() { Thread.currentThread.interrupt }
+ def dispose(): Unit = Thread.interrupted
+ def expose(): Unit = if (Thread.interrupted) throw apply()
+ def impose(): Unit = Thread.currentThread.interrupt
val return_code = 130
}
/* POSIX return code */
def return_code(exn: Throwable, rc: Int): Int =
if (is_interrupt(exn)) Interrupt.return_code else rc
/* message */
def user_message(exn: Throwable): Option[String] =
if (exn.getClass == classOf[RuntimeException] ||
exn.getClass == classOf[User_Error])
{
Some(proper_string(exn.getMessage) getOrElse "Error")
}
else if (exn.isInstanceOf[java.sql.SQLException])
{
Some(proper_string(exn.getMessage) getOrElse "SQL error")
}
else if (exn.isInstanceOf[java.io.IOException])
{
val msg = exn.getMessage
Some(if (msg == null || msg == "") "I/O error" else "I/O error: " + msg)
}
else if (exn.isInstanceOf[RuntimeException]) Some(exn.toString)
else None
def message(exn: Throwable): String =
user_message(exn) getOrElse (if (is_interrupt(exn)) "Interrupt" else exn.toString)
/* trace */
def trace(exn: Throwable): String =
exn.getStackTrace.mkString("\n")
}
diff --git a/src/Pure/General/file.scala b/src/Pure/General/file.scala
--- a/src/Pure/General/file.scala
+++ b/src/Pure/General/file.scala
@@ -1,327 +1,328 @@
/* Title: Pure/General/file.scala
Author: Makarius
File-system operations.
*/
package isabelle
import java.io.{BufferedWriter, OutputStreamWriter, FileOutputStream, BufferedOutputStream,
OutputStream, InputStream, FileInputStream, BufferedInputStream, BufferedReader,
InputStreamReader, File => JFile, IOException}
import java.nio.file.{StandardOpenOption, Path => JPath, Files, SimpleFileVisitor,
FileVisitOption, FileVisitResult}
import java.nio.file.attribute.BasicFileAttributes
import java.net.{URL, MalformedURLException}
import java.util.zip.{GZIPInputStream, GZIPOutputStream}
import java.util.regex.Pattern
import java.util.EnumSet
import org.tukaani.xz.{XZInputStream, XZOutputStream}
import scala.collection.mutable
import scala.util.matching.Regex
object File
{
/* standard path (Cygwin or Posix) */
def standard_path(path: Path): String = path.expand.implode
def standard_path(platform_path: String): String =
if (Platform.is_windows) {
val Platform_Root = new Regex("(?i)" +
Pattern.quote(Isabelle_System.cygwin_root()) + """(?:\\+|\z)(.*)""")
val Drive = new Regex("""([a-zA-Z]):\\*(.*)""")
platform_path.replace('/', '\\') match {
case Platform_Root(rest) => "/" + rest.replace('\\', '/')
case Drive(letter, rest) =>
"/cygdrive/" + Word.lowercase(letter) +
(if (rest == "") "" else "/" + rest.replace('\\', '/'))
case path => path.replace('\\', '/')
}
}
else platform_path
def standard_path(file: JFile): String = standard_path(file.getPath)
def standard_url(name: String): String =
try {
val url = new URL(name)
if (url.getProtocol == "file" && Url.is_wellformed_file(name))
standard_path(Url.parse_file(name))
else name
}
catch { case _: MalformedURLException => standard_path(name) }
/* platform path (Windows or Posix) */
private val Cygdrive = new Regex("/cygdrive/([a-zA-Z])($|/.*)")
private val Named_Root = new Regex("//+([^/]*)(.*)")
def platform_path(standard_path: String): String =
if (Platform.is_windows) {
val result_path = new StringBuilder
val rest =
standard_path match {
case Cygdrive(drive, rest) =>
result_path ++= (Word.uppercase(drive) + ":" + JFile.separator)
rest
case Named_Root(root, rest) =>
result_path ++= JFile.separator
result_path ++= JFile.separator
result_path ++= root
rest
case path if path.startsWith("/") =>
result_path ++= Isabelle_System.cygwin_root()
path
case path => path
}
for (p <- space_explode('/', rest) if p != "") {
val len = result_path.length
if (len > 0 && result_path(len - 1) != JFile.separatorChar)
result_path += JFile.separatorChar
result_path ++= p
}
result_path.toString
}
else standard_path
def platform_path(path: Path): String = platform_path(standard_path(path))
def platform_file(path: Path): JFile = new JFile(platform_path(path))
/* platform files */
def absolute(file: JFile): JFile = file.toPath.toAbsolutePath.normalize.toFile
def absolute_name(file: JFile): String = absolute(file).getPath
def canonical(file: JFile): JFile = file.getCanonicalFile
def canonical_name(file: JFile): String = canonical(file).getPath
def path(file: JFile): Path = Path.explode(standard_path(file))
def pwd(): Path = path(Path.current.absolute_file)
/* relative paths */
def relative_path(base: Path, other: Path): Option[Path] =
{
val base_path = base.file.toPath
val other_path = other.file.toPath
if (other_path.startsWith(base_path))
Some(path(base_path.relativize(other_path).toFile))
else None
}
/* bash path */
def bash_path(path: Path): String = Bash.string(standard_path(path))
def bash_path(file: JFile): String = Bash.string(standard_path(file))
def bash_platform_path(path: Path): String = Bash.string(platform_path(path))
/* directory entries */
def check_dir(path: Path): Path =
if (path.is_dir) path else error("No such directory: " + path)
def check_file(path: Path): Path =
if (path.is_file) path else error("No such file: " + path)
/* directory content */
def read_dir(dir: Path): List[String] =
{
if (!dir.is_dir) error("No such directory: " + dir.toString)
val files = dir.file.listFiles
if (files == null) Nil
else files.toList.map(_.getName).sorted
}
def get_dir(dir: Path): String =
read_dir(dir).filter(name => (dir + Path.basic(name)).is_dir) match {
case List(entry) => entry
case dirs =>
error("Exactly one directory entry expected: " + commas_quote(dirs.sorted))
}
def find_files(
start: JFile,
pred: JFile => Boolean = _ => true,
include_dirs: Boolean = false,
follow_links: Boolean = false): List[JFile] =
{
val result = new mutable.ListBuffer[JFile]
- def check(file: JFile) { if (pred(file)) result += file }
+ def check(file: JFile): Unit = if (pred(file)) result += file
if (start.isFile) check(start)
else if (start.isDirectory) {
val options =
if (follow_links) EnumSet.of(FileVisitOption.FOLLOW_LINKS)
else EnumSet.noneOf(classOf[FileVisitOption])
Files.walkFileTree(start.toPath, options, Integer.MAX_VALUE,
new SimpleFileVisitor[JPath] {
override def preVisitDirectory(path: JPath, attrs: BasicFileAttributes): FileVisitResult =
{
if (include_dirs) check(path.toFile)
FileVisitResult.CONTINUE
}
override def visitFile(path: JPath, attrs: BasicFileAttributes): FileVisitResult =
{
val file = path.toFile
if (include_dirs || !file.isDirectory) check(file)
FileVisitResult.CONTINUE
}
}
)
}
result.toList
}
/* read */
def read(file: JFile): String = Bytes.read(file).text
def read(path: Path): String = read(path.file)
def read_stream(reader: BufferedReader): String =
{
val output = new StringBuilder(100)
var c = -1
while ({ c = reader.read; c != -1 }) output += c.toChar
reader.close
output.toString
}
def read_stream(stream: InputStream): String =
read_stream(new BufferedReader(new InputStreamReader(stream, UTF8.charset)))
def read_gzip(file: JFile): String =
read_stream(new GZIPInputStream(new BufferedInputStream(new FileInputStream(file))))
def read_gzip(path: Path): String = read_gzip(path.file)
def read_xz(file: JFile): String =
read_stream(new XZInputStream(new BufferedInputStream(new FileInputStream(file))))
def read_xz(path: Path): String = read_xz(path.file)
/* read lines */
def read_line(reader: BufferedReader): Option[String] =
{
val line =
try { reader.readLine}
catch { case _: IOException => null }
Option(line).map(Library.trim_line)
}
def read_lines(reader: BufferedReader, progress: String => Unit): List[String] =
{
val result = new mutable.ListBuffer[String]
var line: Option[String] = None
while ({ line = read_line(reader); line.isDefined }) {
progress(line.get)
result += line.get
}
reader.close
result.toList
}
/* write */
def writer(file: JFile): BufferedWriter =
new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), UTF8.charset))
- def write_file(file: JFile, text: CharSequence, make_stream: OutputStream => OutputStream)
+ def write_file(
+ file: JFile, text: CharSequence, make_stream: OutputStream => OutputStream): Unit =
{
val stream = make_stream(new FileOutputStream(file))
using(new BufferedWriter(new OutputStreamWriter(stream, UTF8.charset)))(_.append(text))
}
def write(file: JFile, text: CharSequence): Unit = write_file(file, text, s => s)
def write(path: Path, text: CharSequence): Unit = write(path.file, text)
def write_gzip(file: JFile, text: CharSequence): Unit =
write_file(file, text, (s: OutputStream) => new GZIPOutputStream(new BufferedOutputStream(s)))
def write_gzip(path: Path, text: CharSequence): Unit = write_gzip(path.file, text)
def write_xz(file: JFile, text: CharSequence, options: XZ.Options): Unit =
File.write_file(file, text, s => new XZOutputStream(new BufferedOutputStream(s), options))
def write_xz(file: JFile, text: CharSequence): Unit = write_xz(file, text, XZ.options())
def write_xz(path: Path, text: CharSequence, options: XZ.Options): Unit =
write_xz(path.file, text, options)
def write_xz(path: Path, text: CharSequence): Unit = write_xz(path, text, XZ.options())
- def write_backup(path: Path, text: CharSequence)
+ def write_backup(path: Path, text: CharSequence): Unit =
{
if (path.is_file) Isabelle_System.move_file(path, path.backup)
write(path, text)
}
- def write_backup2(path: Path, text: CharSequence)
+ def write_backup2(path: Path, text: CharSequence): Unit =
{
if (path.is_file) Isabelle_System.move_file(path, path.backup2)
write(path, text)
}
/* change */
def change(file: JFile, f: String => String): Unit = write(file, f(read(file)))
def change(path: Path, f: String => String): Unit = write(path, f(read(path)))
/* append */
def append(file: JFile, text: CharSequence): Unit =
Files.write(file.toPath, UTF8.bytes(text.toString),
StandardOpenOption.APPEND, StandardOpenOption.CREATE)
def append(path: Path, text: CharSequence): Unit = append(path.file, text)
/* eq */
def eq(file1: JFile, file2: JFile): Boolean =
try { Files.isSameFile(file1.toPath, file2.toPath) }
catch { case ERROR(_) => false }
def eq(path1: Path, path2: Path): Boolean = eq(path1.file, path2.file)
/* eq_content */
def eq_content(file1: JFile, file2: JFile): Boolean =
if (eq(file1, file2)) true
else if (file1.length != file2.length) false
else Bytes.read(file1) == Bytes.read(file2)
def eq_content(path1: Path, path2: Path): Boolean = eq_content(path1.file, path2.file)
/* permissions */
def is_executable(path: Path): Boolean =
{
if (Platform.is_windows) Isabelle_System.bash("test -x " + bash_path(path)).check.ok
else path.file.canExecute
}
- def set_executable(path: Path, flag: Boolean)
+ def set_executable(path: Path, flag: Boolean): Unit =
{
if (Platform.is_windows && flag) Isabelle_System.chmod("a+x", path)
else if (Platform.is_windows) Isabelle_System.chmod("a-x", path)
else path.file.setExecutable(flag, false)
}
}
diff --git a/src/Pure/General/file_watcher.scala b/src/Pure/General/file_watcher.scala
--- a/src/Pure/General/file_watcher.scala
+++ b/src/Pure/General/file_watcher.scala
@@ -1,136 +1,136 @@
/* Title: Pure/General/file_watcher.scala
Author: Makarius
Watcher for file-system events.
*/
package isabelle
import java.io.{File => JFile}
import java.nio.file.FileSystems
import java.nio.file.{WatchKey, WatchEvent, Path => JPath}
import java.nio.file.StandardWatchEventKinds.{ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY}
import scala.collection.JavaConverters
class File_Watcher private[File_Watcher] // dummy template
{
- def register(dir: JFile) { }
- def register_parent(file: JFile) { }
- def deregister(dir: JFile) { }
- def purge(retain: Set[JFile]) { }
- def shutdown() { }
+ def register(dir: JFile): Unit = {}
+ def register_parent(file: JFile): Unit = {}
+ def deregister(dir: JFile): Unit = {}
+ def purge(retain: Set[JFile]): Unit = {}
+ def shutdown(): Unit = {}
}
object File_Watcher
{
val none: File_Watcher = new File_Watcher
{
override def toString: String = "File_Watcher.none"
}
def apply(handle: Set[JFile] => Unit, delay: => Time = Time.seconds(0.5)): File_Watcher =
if (Platform.is_windows) none else new Impl(handle, delay)
/* proper implementation */
sealed case class State(
dirs: Map[JFile, WatchKey] = Map.empty,
changed: Set[JFile] = Set.empty)
class Impl private[File_Watcher](handle: Set[JFile] => Unit, delay: Time) extends File_Watcher
{
private val state = Synchronized(File_Watcher.State())
private val watcher = FileSystems.getDefault.newWatchService()
override def toString: String =
state.value.dirs.keySet.mkString("File_Watcher(", ", ", ")")
/* registered directories */
override def register(dir: JFile): Unit =
state.change(st =>
st.dirs.get(dir) match {
case Some(key) if key.isValid => st
case _ =>
val key = dir.toPath.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY)
st.copy(dirs = st.dirs + (dir -> key))
})
override def register_parent(file: JFile): Unit =
{
val dir = file.getParentFile
if (dir != null && dir.isDirectory) register(dir)
}
override def deregister(dir: JFile): Unit =
state.change(st =>
st.dirs.get(dir) match {
case None => st
case Some(key) =>
key.cancel
st.copy(dirs = st.dirs - dir)
})
override def purge(retain: Set[JFile]): Unit =
state.change(st =>
st.copy(dirs = st.dirs --
(for ((dir, key) <- st.dirs.iterator if !retain(dir)) yield { key.cancel; dir })))
/* changed directory entries */
private val delay_changed = Delay.last(delay)
{
val changed = state.change_result(st => (st.changed, st.copy(changed = Set.empty)))
handle(changed)
}
private val watcher_thread = Isabelle_Thread.fork(name = "file_watcher", daemon = true)
{
try {
while (true) {
val key = watcher.take
val has_changed =
state.change_result(st =>
{
val (remove, changed) =
st.dirs.collectFirst({ case (dir, key1) if key == key1 => dir }) match {
case Some(dir) =>
val events =
JavaConverters.collectionAsScalaIterable(
key.pollEvents.asInstanceOf[java.util.List[WatchEvent[JPath]]])
val remove = if (key.reset) None else Some(dir)
val changed =
(Set.empty[JFile] /: events.iterator) {
case (set, event) => set + dir.toPath.resolve(event.context).toFile
}
(remove, changed)
case None =>
key.pollEvents
key.reset
(None, Set.empty[JFile])
}
(changed.nonEmpty, st.copy(dirs = st.dirs -- remove, changed = st.changed ++ changed))
})
if (has_changed) delay_changed.invoke()
}
}
catch { case Exn.Interrupt() => }
}
/* shutdown */
- override def shutdown()
+ override def shutdown(): Unit =
{
watcher_thread.interrupt
watcher_thread.join
delay_changed.revoke
}
}
}
diff --git a/src/Pure/General/graphics_file.scala b/src/Pure/General/graphics_file.scala
--- a/src/Pure/General/graphics_file.scala
+++ b/src/Pure/General/graphics_file.scala
@@ -1,93 +1,94 @@
/* Title: Pure/General/graphics_file.scala
Author: Makarius
File system operations for Graphics2D output.
*/
package isabelle
import java.io.{FileOutputStream, BufferedOutputStream, File => JFile}
import java.awt.Graphics2D
import java.awt.geom.Rectangle2D
import java.awt.image.BufferedImage
import javax.imageio.ImageIO
import org.jfree.chart.JFreeChart
import com.lowagie.text.pdf.{PdfWriter, BaseFont, FontMapper, DefaultFontMapper}
object Graphics_File
{
/* PNG */
- def write_png(file: JFile, paint: Graphics2D => Unit, width: Int, height: Int, dpi: Int = 72)
+ def write_png(
+ file: JFile, paint: Graphics2D => Unit, width: Int, height: Int, dpi: Int = 72): Unit =
{
val scale = dpi / 72.0f
val w = (width * scale).round
val h = (height * scale).round
val img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB)
val gfx = img.createGraphics
try {
gfx.scale(scale, scale)
paint(gfx)
ImageIO.write(img, "png", file)
}
finally { gfx.dispose }
}
/* PDF */
private def font_mapper(): FontMapper =
{
val mapper = new DefaultFontMapper
for (entry <- Isabelle_Fonts.fonts()) {
val params = new DefaultFontMapper.BaseFontParameters(File.platform_path(entry.path))
params.encoding = BaseFont.IDENTITY_H
params.embedded = true
params.ttfAfm = entry.bytes.array
mapper.putName(entry.name, params)
}
mapper
}
- def write_pdf(file: JFile, paint: Graphics2D => Unit, width: Int, height: Int)
+ def write_pdf(file: JFile, paint: Graphics2D => Unit, width: Int, height: Int): Unit =
{
import com.lowagie.text.{Document, Rectangle}
using(new BufferedOutputStream(new FileOutputStream(file)))(out =>
{
val document = new Document()
try {
document.setPageSize(new Rectangle(width, height))
val writer = PdfWriter.getInstance(document, out)
document.open()
val cb = writer.getDirectContent()
val tp = cb.createTemplate(width, height)
val gfx = tp.createGraphics(width, height, font_mapper())
paint(gfx)
gfx.dispose
cb.addTemplate(tp, 1, 0, 0, 1, 0, 0)
}
finally { document.close() }
})
}
/* JFreeChart */
def paint_chart(gfx: Graphics2D, chart: JFreeChart, width: Int, height: Int): Unit =
chart.draw(gfx, new Rectangle2D.Double(0, 0, width, height))
def write_chart_png(file: JFile, chart: JFreeChart, width: Int, height: Int): Unit =
write_png(file, paint_chart(_, chart, width, height), width, height)
def write_chart_pdf(file: JFile, chart: JFreeChart, width: Int, height: Int): Unit =
write_pdf(file, paint_chart(_, chart, width, height), width, height)
}
diff --git a/src/Pure/General/http.scala b/src/Pure/General/http.scala
--- a/src/Pure/General/http.scala
+++ b/src/Pure/General/http.scala
@@ -1,166 +1,166 @@
/* Title: Pure/General/http.scala
Author: Makarius
HTTP server support.
*/
package isabelle
import java.net.{InetAddress, InetSocketAddress, URI}
import com.sun.net.httpserver.{HttpExchange, HttpHandler, HttpServer}
import scala.collection.immutable.SortedMap
object HTTP
{
/** server **/
/* response */
object Response
{
def apply(
bytes: Bytes = Bytes.empty,
content_type: String = "application/octet-stream"): Response =
new Response(bytes, content_type)
val empty: Response = apply()
def text(s: String): Response = apply(Bytes(s), "text/plain; charset=utf-8")
def html(s: String): Response = apply(Bytes(s), "text/html; charset=utf-8")
}
class Response private[HTTP](val bytes: Bytes, val content_type: String)
{
override def toString: String = bytes.toString
}
/* exchange */
class Exchange private[HTTP](val http_exchange: HttpExchange)
{
def request_method: String = http_exchange.getRequestMethod
def request_uri: URI = http_exchange.getRequestURI
def read_request(): Bytes =
using(http_exchange.getRequestBody)(Bytes.read_stream(_))
- def write_response(code: Int, response: Response)
+ def write_response(code: Int, response: Response): Unit =
{
http_exchange.getResponseHeaders().set("Content-Type", response.content_type)
http_exchange.sendResponseHeaders(code, response.bytes.length.toLong)
using(http_exchange.getResponseBody)(response.bytes.write_stream(_))
}
}
/* handler */
class Handler private[HTTP](val root: String, val handler: HttpHandler)
{
override def toString: String = root
}
def handler(root: String, body: Exchange => Unit): Handler =
- new Handler(root, new HttpHandler { def handle(x: HttpExchange) { body(new Exchange(x)) } })
+ new Handler(root, new HttpHandler { def handle(x: HttpExchange): Unit = body(new Exchange(x)) })
/* particular methods */
sealed case class Arg(method: String, uri: URI, request: Bytes)
{
def decode_properties: Properties.T =
space_explode('&', request.text).map(s =>
space_explode('=', s) match {
case List(a, b) => Url.decode(a) -> Url.decode(b)
case _ => error("Malformed key-value pair in HTTP/POST: " + quote(s))
})
}
def method(name: String, root: String, body: Arg => Option[Response]): Handler =
handler(root, http =>
{
val request = http.read_request()
if (http.request_method == name) {
val arg = Arg(name, http.request_uri, request)
Exn.capture(body(arg)) match {
case Exn.Res(Some(response)) =>
http.write_response(200, response)
case Exn.Res(None) =>
http.write_response(404, Response.empty)
case Exn.Exn(ERROR(msg)) =>
http.write_response(500, Response.text(Output.error_message_text(msg)))
case Exn.Exn(exn) => throw exn
}
}
else http.write_response(400, Response.empty)
})
def get(root: String, body: Arg => Option[Response]): Handler = method("GET", root, body)
def post(root: String, body: Arg => Option[Response]): Handler = method("POST", root, body)
/* server */
class Server private[HTTP](val http_server: HttpServer)
{
- def += (handler: Handler) { http_server.createContext(handler.root, handler.handler) }
- def -= (handler: Handler) { http_server.removeContext(handler.root) }
+ def += (handler: Handler): Unit = http_server.createContext(handler.root, handler.handler)
+ def -= (handler: Handler): Unit = http_server.removeContext(handler.root)
def start: Unit = http_server.start
def stop: Unit = http_server.stop(0)
def address: InetSocketAddress = http_server.getAddress
def url: String = "http://" + address.getHostName + ":" + address.getPort
override def toString: String = url
}
def server(handlers: List[Handler] = isabelle_resources): Server =
{
val http_server = HttpServer.create(new InetSocketAddress(isabelle.Server.localhost, 0), 0)
http_server.setExecutor(null)
val server = new Server(http_server)
for (handler <- handlers) server += handler
server
}
/** Isabelle resources **/
lazy val isabelle_resources: List[Handler] =
List(welcome, fonts())
/* welcome */
val welcome: Handler =
get("/", arg =>
if (arg.uri.toString == "/") {
val id = Isabelle_System.isabelle_id()
Some(Response.text("Welcome to Isabelle/" + id + ": " + Distribution.version))
}
else None)
/* fonts */
private lazy val html_fonts: List[Isabelle_Fonts.Entry] =
Isabelle_Fonts.fonts(hidden = true)
def fonts(root: String = "/fonts"): Handler =
get(root, arg =>
{
val uri_name = arg.uri.toString
if (uri_name == root) {
Some(Response.text(cat_lines(html_fonts.map(entry => entry.path.file_name))))
}
else {
html_fonts.collectFirst(
{ case entry if uri_name == root + "/" + entry.path.file_name => Response(entry.bytes) })
}
})
}
diff --git a/src/Pure/General/json.scala b/src/Pure/General/json.scala
--- a/src/Pure/General/json.scala
+++ b/src/Pure/General/json.scala
@@ -1,414 +1,414 @@
/* Title: Pure/General/json.scala
Author: Makarius
Support for JSON: https://www.json.org/.
See also http://seriot.ch/parsing_json.php "Parsing JSON is a Minefield".
*/
package isabelle
import scala.util.matching.Regex
import scala.util.parsing.combinator.Parsers
import scala.util.parsing.combinator.lexical.Scanners
import scala.util.parsing.input.CharArrayReader.EofCh
object JSON
{
type T = Any
type S = String
object Object
{
type Entry = (String, JSON.T)
type T = Map[String, JSON.T]
val empty: Object.T = Map.empty
def apply(entries: Entry*): Object.T = Map(entries:_*)
def unapply(obj: Any): Option[Object.T] =
obj match {
case m: Map[_, _] if m.keySet.forall(_.isInstanceOf[String]) =>
Some(m.asInstanceOf[Object.T])
case _ => None
}
}
/* lexer */
object Kind extends Enumeration
{
val KEYWORD, STRING, NUMBER, ERROR = Value
}
sealed case class Token(kind: Kind.Value, text: String)
{
def is_keyword: Boolean = kind == Kind.KEYWORD
def is_keyword(name: String): Boolean = kind == Kind.KEYWORD && text == name
def is_string: Boolean = kind == Kind.STRING
def is_number: Boolean = kind == Kind.NUMBER
def is_error: Boolean = kind == Kind.ERROR
}
object Lexer extends Scanners with Scan.Parsers
{
override type Elem = Char
type Token = JSON.Token
def errorToken(msg: String): Token = Token(Kind.ERROR, msg)
val white_space: String = " \t\n\r"
override val whiteSpace: Regex = ("[" + white_space + "]+").r
def whitespace: Parser[Any] = many(character(white_space.contains(_)))
val letter: Parser[String] = one(character(Symbol.is_ascii_letter))
val letters1: Parser[String] = many1(character(Symbol.is_ascii_letter))
def digits: Parser[String] = many(character(Symbol.is_ascii_digit))
def digits1: Parser[String] = many1(character(Symbol.is_ascii_digit))
/* keyword */
def keyword: Parser[Token] =
(letters1 | one(character("{}[],:".contains(_)))) ^^ (s => Token(Kind.KEYWORD, s))
/* string */
def string: Parser[Token] =
'\"' ~> rep(string_body) <~ '\"' ^^ (cs => Token(Kind.STRING, cs.mkString))
def string_body: Parser[Char] =
elem("", c => c > '\u001f' && c != '\"' && c != '\\' && c != EofCh) | '\\' ~> string_escape
def string_escape: Parser[Char] =
elem("", "\"\\/".contains(_)) |
elem("", "bfnrt".contains(_)) ^^
{ case 'b' => '\b' case 'f' => '\f' case 'n' => '\n' case 'r' => '\r' case 't' => '\t' } |
'u' ~> repeated(character("0123456789abcdefABCDEF".contains(_)), 4, 4) ^^
(s => Integer.parseInt(s, 16).toChar)
def string_failure: Parser[Token] = '\"' ~> failure("Unterminated string")
/* number */
def number: Parser[Token] =
opt("-") ~ number_body ~ opt(letter) ^^ {
case a ~ b ~ None => Token(Kind.NUMBER, a.getOrElse("") + b)
case a ~ b ~ Some(c) =>
errorToken("Invalid number format: " + quote(a.getOrElse("") + b + c))
}
def number_body: Parser[String] =
(zero | positive) ~ opt(number_fract) ~ opt(number_exp) ^^
{ case a ~ b ~ c => a + b.getOrElse("") + c.getOrElse("") }
def number_fract: Parser[String] = "." ~ digits1 ^^ { case a ~ b => a + b }
def number_exp: Parser[String] =
one(character("eE".contains(_))) ~ maybe(character("-+".contains(_))) ~ digits1 ^^
{ case a ~ b ~ c => a + b + c }
def zero: Parser[String] = one(character(c => c == '0'))
def nonzero: Parser[String] = one(character(c => c != '0' && Symbol.is_ascii_digit(c)))
def positive: Parser[String] = nonzero ~ digits ^^ { case a ~ b => a + b }
/* token */
def token: Parser[Token] =
keyword | (string | (string_failure | (number | failure("Illegal character"))))
}
/* parser */
trait Parser extends Parsers
{
type Elem = Token
def $$$(name: String): Parser[Token] = elem(name, _.is_keyword(name))
def string: Parser[String] = elem("string", _.is_string) ^^ (_.text)
def number: Parser[Double] = elem("number", _.is_number) ^^ (tok => tok.text.toDouble)
def json_object: Parser[Object.T] =
$$$("{") ~>
repsep(string ~ ($$$(":") ~> json_value) ^^ { case a ~ b => (a, b) }, $$$(",")) <~
$$$("}") ^^ (_.toMap)
def json_array: Parser[List[T]] =
$$$("[") ~> repsep(json_value, $$$(",")) <~ $$$("]")
def json_value: Parser[T] =
json_object | (json_array | (number | (string |
($$$("true") ^^^ true | ($$$("false") ^^^ false | ($$$("null") ^^^ null))))))
def parse(input: CharSequence, strict: Boolean): T =
{
val scanner = new Lexer.Scanner(Scan.char_reader(input))
phrase(if (strict) json_object | json_array else json_value)(scanner) match {
case Success(json, _) => json
case NoSuccess(_, next) => error("Malformed JSON input at " + next.pos)
}
}
}
object Parser extends Parser
/* standard format */
def parse(s: S, strict: Boolean = true): T = Parser.parse(s, strict)
object Format
{
def unapply(s: S): Option[T] =
try { Some(parse(s, strict = false)) }
catch { case ERROR(_) => None }
def apply(json: T): S =
{
val result = new StringBuilder
- def string(s: String)
+ def string(s: String): Unit =
{
result += '"'
result ++=
s.iterator.map {
case '"' => "\\\""
case '\\' => "\\\\"
case '\b' => "\\b"
case '\f' => "\\f"
case '\n' => "\\n"
case '\r' => "\\r"
case '\t' => "\\t"
case c =>
if (c <= '\u001f' || c >= '\u007f' && c <= '\u009f') "\\u%04x".format(c.toInt)
else c
}.mkString
result += '"'
}
- def array(list: List[T])
+ def array(list: List[T]): Unit =
{
result += '['
Library.separate(None, list.map(Some(_))).foreach({
case None => result += ','
case Some(x) => json_format(x)
})
result += ']'
}
- def object_(obj: Object.T)
+ def object_(obj: Object.T): Unit =
{
result += '{'
Library.separate(None, obj.toList.map(Some(_))).foreach({
case None => result += ','
case Some((x, y)) =>
string(x)
result += ':'
json_format(y)
})
result += '}'
}
- def json_format(x: T)
+ def json_format(x: T): Unit =
{
x match {
case null => result ++= "null"
case _: Int | _: Long | _: Boolean => result ++= x.toString
case n: Double =>
val i = n.toLong
result ++= (if (i.toDouble == n) i.toString else n.toString)
case s: String => string(s)
case Object(m) => object_(m)
case list: List[T] => array(list)
case _ => error("Bad JSON value: " + x.toString)
}
}
json_format(json)
result.toString
}
}
/* typed values */
object Value
{
object UUID
{
def unapply(json: T): Option[isabelle.UUID.T] =
json match {
case x: java.lang.String => isabelle.UUID.unapply(x)
case _ => None
}
}
object String
{
def unapply(json: T): Option[java.lang.String] =
json match {
case x: java.lang.String => Some(x)
case _ => None
}
}
object String0
{
def unapply(json: T): Option[java.lang.String] =
json match {
case null => Some("")
case x: java.lang.String => Some(x)
case _ => None
}
}
object Double
{
def unapply(json: T): Option[scala.Double] =
json match {
case x: scala.Double => Some(x)
case x: scala.Long => Some(x.toDouble)
case x: scala.Int => Some(x.toDouble)
case _ => None
}
}
object Long
{
def unapply(json: T): Option[scala.Long] =
json match {
case x: scala.Double if x.toLong.toDouble == x => Some(x.toLong)
case x: scala.Long => Some(x)
case x: scala.Int => Some(x.toLong)
case _ => None
}
}
object Int
{
def unapply(json: T): Option[scala.Int] =
json match {
case x: scala.Double if x.toInt.toDouble == x => Some(x.toInt)
case x: scala.Long if x.toInt.toLong == x => Some(x.toInt)
case x: scala.Int => Some(x)
case _ => None
}
}
object Boolean
{
def unapply(json: T): Option[scala.Boolean] =
json match {
case x: scala.Boolean => Some(x)
case _ => None
}
}
object List
{
def unapply[A](json: T, unapply: T => Option[A]): Option[List[A]] =
json match {
case xs: List[T] =>
val ys = xs.map(unapply)
if (ys.forall(_.isDefined)) Some(ys.map(_.get)) else None
case _ => None
}
}
object Seconds
{
def unapply(json: T): Option[Time] =
Double.unapply(json).map(Time.seconds)
}
}
/* object values */
def optional(entry: (String, Option[T])): Object.T =
entry match {
case (name, Some(x)) => Object(name -> x)
case (_, None) => Object.empty
}
def value(obj: T, name: String): Option[T] =
obj match {
case Object(m) => m.get(name)
case _ => None
}
def value[A](obj: T, name: String, unapply: T => Option[A]): Option[A] =
for {
json <- value(obj, name)
x <- unapply(json)
} yield x
def array(obj: T, name: String): Option[List[T]] =
value(obj, name) match {
case Some(a: List[T]) => Some(a)
case _ => None
}
def value_default[A](obj: T, name: String, unapply: T => Option[A], default: => A): Option[A] =
value(obj, name) match {
case None => Some(default)
case Some(json) => unapply(json)
}
def uuid(obj: T, name: String): Option[UUID.T] =
value(obj, name, Value.UUID.unapply)
def string(obj: T, name: String): Option[String] =
value(obj, name, Value.String.unapply)
def string_default(obj: T, name: String, default: => String = ""): Option[String] =
value_default(obj, name, Value.String.unapply, default)
def string0(obj: T, name: String): Option[String] =
value(obj, name, Value.String0.unapply)
def string0_default(obj: T, name: String, default: => String = ""): Option[String] =
value_default(obj, name, Value.String0.unapply, default)
def double(obj: T, name: String): Option[Double] =
value(obj, name, Value.Double.unapply)
def double_default(obj: T, name: String, default: => Double = 0.0): Option[Double] =
value_default(obj, name, Value.Double.unapply, default)
def long(obj: T, name: String): Option[Long] =
value(obj, name, Value.Long.unapply)
def long_default(obj: T, name: String, default: => Long = 0): Option[Long] =
value_default(obj, name, Value.Long.unapply, default)
def int(obj: T, name: String): Option[Int] =
value(obj, name, Value.Int.unapply)
def int_default(obj: T, name: String, default: => Int = 0): Option[Int] =
value_default(obj, name, Value.Int.unapply, default)
def bool(obj: T, name: String): Option[Boolean] =
value(obj, name, Value.Boolean.unapply)
def bool_default(obj: T, name: String, default: => Boolean = false): Option[Boolean] =
value_default(obj, name, Value.Boolean.unapply, default)
def list[A](obj: T, name: String, unapply: T => Option[A]): Option[List[A]] =
value(obj, name, Value.List.unapply(_, unapply))
def list_default[A](obj: T, name: String, unapply: T => Option[A], default: => List[A] = Nil)
: Option[List[A]] = value_default(obj, name, Value.List.unapply(_, unapply), default)
def strings(obj: T, name: String): Option[List[String]] =
list(obj, name, JSON.Value.String.unapply)
def strings_default(obj: T, name: String, default: => List[String] = Nil): Option[List[String]] =
list_default(obj, name, JSON.Value.String.unapply, default)
def seconds(obj: T, name: String): Option[Time] =
value(obj, name, Value.Seconds.unapply)
def seconds_default(obj: T, name: String, default: => Time = Time.zero): Option[Time] =
value_default(obj, name, Value.Seconds.unapply, default)
}
diff --git a/src/Pure/General/linear_set.scala b/src/Pure/General/linear_set.scala
--- a/src/Pure/General/linear_set.scala
+++ b/src/Pure/General/linear_set.scala
@@ -1,164 +1,164 @@
/* Title: Pure/General/linear_set.scala
Author: Makarius
Author: Fabian Immler, TU Munich
Sets with canonical linear order, or immutable linked-lists.
*/
package isabelle
import scala.collection.mutable
import scala.collection.immutable.SetOps
import scala.collection.{IterableFactory, IterableFactoryDefaults}
object Linear_Set extends IterableFactory[Linear_Set]
{
private val empty_val: Linear_Set[Nothing] = new Linear_Set[Nothing](None, None, Map(), Map())
override def empty[A]: Linear_Set[A] = empty_val.asInstanceOf[Linear_Set[A]]
def from[A](entries: IterableOnce[A]): Linear_Set[A] = (empty[A] /: entries)(_.incl(_))
override def newBuilder[A]: mutable.Builder[A, Linear_Set[A]] = new Builder[A]
private class Builder[A] extends mutable.Builder[A, Linear_Set[A]]
{
private var res = empty[A]
- override def clear() { res = empty[A] }
+ override def clear(): Unit = { res = empty[A] }
override def addOne(elem: A): this.type = { res = res.incl(elem); this }
override def result(): Linear_Set[A] = res
}
class Duplicate[A](x: A) extends Exception
class Undefined[A](x: A) extends Exception
class Next_Undefined[A](x: Option[A]) extends Exception
}
final class Linear_Set[A] private(
start: Option[A], end: Option[A], val nexts: Map[A, A], prevs: Map[A, A])
extends Iterable[A]
with SetOps[A, Linear_Set, Linear_Set[A]]
with IterableFactoryDefaults[A, Linear_Set]
{
/* relative addressing */
def next(elem: A): Option[A] =
if (contains(elem)) nexts.get(elem)
else throw new Linear_Set.Undefined(elem)
def prev(elem: A): Option[A] =
if (contains(elem)) prevs.get(elem)
else throw new Linear_Set.Undefined(elem)
def get_after(hook: Option[A]): Option[A] =
hook match {
case None => start
case Some(elem) => next(elem)
}
def insert_after(hook: Option[A], elem: A): Linear_Set[A] =
if (contains(elem)) throw new Linear_Set.Duplicate(elem)
else
hook match {
case None =>
start match {
case None => new Linear_Set[A](Some(elem), Some(elem), Map(), Map())
case Some(elem1) =>
new Linear_Set[A](Some(elem), end,
nexts + (elem -> elem1), prevs + (elem1 -> elem))
}
case Some(elem1) =>
if (!contains(elem1)) throw new Linear_Set.Undefined(elem1)
else
nexts.get(elem1) match {
case None =>
new Linear_Set[A](start, Some(elem),
nexts + (elem1 -> elem), prevs + (elem -> elem1))
case Some(elem2) =>
new Linear_Set[A](start, end,
nexts + (elem1 -> elem) + (elem -> elem2),
prevs + (elem2 -> elem) + (elem -> elem1))
}
}
def append_after(hook: Option[A], elems: Iterable[A]): Linear_Set[A] = // FIXME reverse fold
((hook, this) /: elems) {
case ((last, set), elem) => (Some(elem), set.insert_after(last, elem))
}._2
def delete_after(hook: Option[A]): Linear_Set[A] =
hook match {
case None =>
start match {
case None => throw new Linear_Set.Next_Undefined[A](None)
case Some(elem1) =>
nexts.get(elem1) match {
case None => empty
case Some(elem2) =>
new Linear_Set[A](Some(elem2), end, nexts - elem1, prevs - elem2)
}
}
case Some(elem1) =>
if (!contains(elem1)) throw new Linear_Set.Undefined(elem1)
else
nexts.get(elem1) match {
case None => throw new Linear_Set.Next_Undefined(Some(elem1))
case Some(elem2) =>
nexts.get(elem2) match {
case None =>
new Linear_Set[A](start, Some(elem1), nexts - elem1, prevs - elem2)
case Some(elem3) =>
new Linear_Set[A](start, end,
nexts - elem2 + (elem1 -> elem3),
prevs - elem2 + (elem3 -> elem1))
}
}
}
/* Set methods */
override def isEmpty: Boolean = start.isEmpty
override def size: Int = if (isEmpty) 0 else nexts.size + 1
def contains(elem: A): Boolean =
nonEmpty && (end.get == elem || nexts.isDefinedAt(elem))
private def make_iterator(from: Option[A]): Iterator[A] = new Iterator[A] {
private var next_elem = from
def hasNext: Boolean = next_elem.isDefined
def next(): A =
next_elem match {
case Some(elem) =>
next_elem = nexts.get(elem)
elem
case None => Iterator.empty.next()
}
}
override def iterator: Iterator[A] = make_iterator(start)
def iterator(elem: A): Iterator[A] =
if (contains(elem)) make_iterator(Some(elem))
else throw new Linear_Set.Undefined(elem)
def iterator(from: A, to: A): Iterator[A] =
if (contains(to))
nexts.get(to) match {
case None => iterator(from)
case Some(stop) => iterator(from).takeWhile(_ != stop)
}
else throw new Linear_Set.Undefined(to)
def reverse: Linear_Set[A] = new Linear_Set(end, start, prevs, nexts)
override def last: A = reverse.head
def incl(elem: A): Linear_Set[A] = insert_after(end, elem)
def excl(elem: A): Linear_Set[A] = delete_after(prev(elem))
override def iterableFactory: IterableFactory[Linear_Set] = Linear_Set
override def toString: String = mkString("Linear_Set(", ", ", ")")
}
diff --git a/src/Pure/General/logger.scala b/src/Pure/General/logger.scala
--- a/src/Pure/General/logger.scala
+++ b/src/Pure/General/logger.scala
@@ -1,34 +1,34 @@
/* Title: Pure/General/logger.scala
Author: Makarius
Minimal logging support.
*/
package isabelle
object Logger
{
def make(log_file: Option[Path]): Logger =
log_file match { case Some(file) => new File_Logger(file) case None => No_Logger }
}
trait Logger
{
def apply(msg: => String): Unit
def timeit[A](message: String = "", enabled: Boolean = true)(e: => A): A =
Timing.timeit(message, enabled, apply(_))(e)
}
object No_Logger extends Logger
{
- def apply(msg: => String) { }
+ def apply(msg: => String): Unit = {}
}
class File_Logger(path: Path) extends Logger
{
- def apply(msg: => String) { synchronized { File.append(path, msg + "\n") } }
+ def apply(msg: => String): Unit = synchronized { File.append(path, msg + "\n") }
override def toString: String = path.toString
}
diff --git a/src/Pure/General/mercurial.scala b/src/Pure/General/mercurial.scala
--- a/src/Pure/General/mercurial.scala
+++ b/src/Pure/General/mercurial.scala
@@ -1,336 +1,337 @@
/* Title: Pure/General/mercurial.scala
Author: Makarius
Support for Mercurial repositories, with local or remote repository clone
and working directory (via ssh connection).
*/
package isabelle
import java.io.{File => JFile}
import scala.annotation.tailrec
import scala.collection.mutable
object Mercurial
{
type Graph = isabelle.Graph[String, Unit]
/* command-line syntax */
def optional(s: String, prefix: String = ""): String =
if (s == "") "" else " " + prefix + " " + Bash.string(s)
def opt_flag(flag: String, b: Boolean): String = if (b) " " + flag else ""
def opt_rev(s: String): String = optional(s, "--rev")
def opt_template(s: String): String = optional(s, "--template")
/* repository access */
def is_repository(root: Path, ssh: SSH.System = SSH.Local): Boolean =
ssh.is_dir(root + Path.explode(".hg")) &&
new Repository(root, ssh).command("root").ok
def repository(root: Path, ssh: SSH.System = SSH.Local): Repository =
{
val hg = new Repository(root, ssh)
hg.command("root").check
hg
}
def find_repository(start: Path, ssh: SSH.System = SSH.Local): Option[Repository] =
{
@tailrec def find(root: Path): Option[Repository] =
if (is_repository(root, ssh)) Some(repository(root, ssh = ssh))
else if (root.is_root) None
else find(root + Path.parent)
find(ssh.expand_path(start))
}
private def make_repository(root: Path, cmd: String, args: String, ssh: SSH.System = SSH.Local)
: Repository =
{
val hg = new Repository(root, ssh)
ssh.make_directory(hg.root.dir)
hg.command(cmd, args, repository = false).check
hg
}
def init_repository(root: Path, ssh: SSH.System = SSH.Local): Repository =
make_repository(root, "init", ssh.bash_path(root), ssh = ssh)
def clone_repository(source: String, root: Path,
rev: String = "", options: String = "", ssh: SSH.System = SSH.Local): Repository =
make_repository(root, "clone",
options + " " + Bash.string(source) + " " + ssh.bash_path(root) + opt_rev(rev), ssh = ssh)
def setup_repository(source: String, root: Path, ssh: SSH.System = SSH.Local): Repository =
{
if (ssh.is_dir(root)) { val hg = repository(root, ssh = ssh); hg.pull(remote = source); hg }
else clone_repository(source, root, options = "--noupdate", ssh = ssh)
}
class Repository private[Mercurial](root_path: Path, ssh: SSH.System = SSH.Local)
{
hg =>
val root: Path = ssh.expand_path(root_path)
def root_url: String = ssh.hg_url + root.implode
override def toString: String = ssh.hg_url + root.implode
def command(name: String, args: String = "", options: String = "",
repository: Boolean = true): Process_Result =
{
val cmdline =
"export HGPLAIN=\n\"${HG:-hg}\" --config " + Bash.string("defaults." + name + "=") +
(if (repository) " --repository " + ssh.bash_path(root) else "") +
" --noninteractive " + name + " " + options + " " + args
ssh.execute(cmdline)
}
def add(files: List[Path]): Unit =
hg.command("add", files.map(ssh.bash_path).mkString(" "))
def archive(target: String, rev: String = "", options: String = ""): Unit =
hg.command("archive", opt_rev(rev) + " " + Bash.string(target), options).check
def heads(template: String = "{node|short}\n", options: String = ""): List[String] =
hg.command("heads", opt_template(template), options).check.out_lines
def identify(rev: String = "tip", options: String = ""): String =
hg.command("id", opt_rev(rev), options).check.out_lines.headOption getOrElse ""
def id(rev: String = "tip"): String = identify(rev, options = "-i")
def paths(args: String = "", options: String = ""): List[String] =
hg.command("paths", args = args, options = options).check.out_lines
def manifest(rev: String = "", options: String = ""): List[String] =
hg.command("manifest", opt_rev(rev), options).check.out_lines
def log(rev: String = "", template: String = "", options: String = ""): String =
hg.command("log", opt_rev(rev) + opt_template(template), options).check.out
def parent(): String = log(rev = "p1()", template = "{node|short}")
- def push(remote: String = "", rev: String = "", force: Boolean = false, options: String = "")
+ def push(
+ remote: String = "", rev: String = "", force: Boolean = false, options: String = ""): Unit =
{
hg.command("push", opt_rev(rev) + opt_flag("--force", force) + optional(remote), options).
check_rc(rc => rc == 0 | rc == 1)
}
def pull(remote: String = "", rev: String = "", options: String = ""): Unit =
hg.command("pull", opt_rev(rev) + optional(remote), options).check
def update(
- rev: String = "", clean: Boolean = false, check: Boolean = false, options: String = "")
+ rev: String = "", clean: Boolean = false, check: Boolean = false, options: String = ""): Unit =
{
hg.command("update",
opt_rev(rev) + opt_flag("--clean", clean) + opt_flag("--check", check), options).check
}
def known_files(): List[String] =
hg.command("status", options = "--modified --added --clean --no-status").check.out_lines
def graph(): Graph =
{
val Node = """^node: (\w{12}) (\w{12}) (\w{12})""".r
val log_result =
log(template = """node: {node|short} {p1node|short} {p2node|short}\n""")
(Graph.string[Unit] /: split_lines(log_result)) {
case (graph, Node(x, y, z)) =>
val deps = List(y, z).filterNot(s => s.forall(_ == '0'))
val graph1 = (graph /: (x :: deps))(_.default_node(_, ()))
(graph1 /: deps)({ case (g, dep) => g.add_edge(dep, x) })
case (graph, _) => graph
}
}
}
/* check files */
def check_files(files: List[Path], ssh: SSH.System = SSH.Local): (List[Path], List[Path]) =
{
val outside = new mutable.ListBuffer[Path]
val unknown = new mutable.ListBuffer[Path]
- @tailrec def check(paths: List[Path])
+ @tailrec def check(paths: List[Path]): Unit =
{
paths match {
case path :: rest =>
find_repository(path, ssh) match {
case None => outside += path; check(rest)
case Some(hg) =>
val known =
hg.known_files().iterator.map(name =>
(hg.root + Path.explode(name)).canonical_file).toSet
if (!known(path.canonical_file)) unknown += path
check(rest.filterNot(p => known(p.canonical_file)))
}
case Nil =>
}
}
check(files)
(outside.toList, unknown.toList)
}
/* setup remote vs. local repository */
- private def edit_hgrc(local_hg: Repository, path_name: String, source: String)
+ private def edit_hgrc(local_hg: Repository, path_name: String, source: String): Unit =
{
val hgrc = local_hg.root + Path.explode(".hg/hgrc")
def header(line: String): Boolean = line.startsWith("[paths]")
val Entry = """^(\S+)\s*=\s*(.*)$""".r
val new_entry = path_name + " = " + source
def commit(lines: List[String]): Boolean =
{
File.write(hgrc, cat_lines(lines))
true
}
val edited =
hgrc.is_file && {
val lines = split_lines(File.read(hgrc))
lines.count(header) == 1 && {
if (local_hg.paths(options = "-q").contains(path_name)) {
val old_source = local_hg.paths(args = path_name).head
val old_entry = path_name + ".old = " + old_source
val lines1 =
lines.map {
case Entry(a, b) if a == path_name && b == old_source =>
new_entry + "\n" + old_entry
case line => line
}
lines != lines1 && commit(lines1)
}
else {
val prefix = lines.takeWhile(line => !header(line))
val n = prefix.length
commit(prefix ::: List(lines(n), new_entry) ::: lines.drop(n + 1))
}
}
}
if (!edited) File.append(hgrc, "\n[paths]\n" + new_entry + "\n")
}
val default_path_name = "default"
def hg_setup(
remote: String,
local_path: Path,
remote_name: String = "",
path_name: String = default_path_name,
remote_exists: Boolean = false,
- progress: Progress = new Progress)
+ progress: Progress = new Progress): Unit =
{
/* local repository */
Isabelle_System.make_directory(local_path)
val repos_name =
proper_string(remote_name) getOrElse local_path.absolute.base.implode
val local_hg =
if (is_repository(local_path)) repository(local_path)
else init_repository(local_path)
progress.echo("Local repository " + local_hg.root.absolute)
/* remote repository */
val remote_url =
remote match {
case _ if remote.startsWith("ssh://") =>
val ssh_url = remote + "/" + repos_name
if (!remote_exists) {
try { local_hg.command("init", ssh_url, repository = false).check }
catch { case ERROR(msg) => progress.echo_warning(msg) }
}
ssh_url
case SSH.Target(user, host) =>
val phabricator = Phabricator.API(user, host)
var repos =
phabricator.get_repositories().find(r => r.short_name == repos_name) getOrElse {
if (remote_exists) {
error("Remote repository " +
quote(phabricator.hg_url + "/source/" + repos_name) + " expected to exist")
}
else phabricator.create_repository(repos_name, short_name = repos_name)
}
while (repos.importing) {
progress.echo("Awaiting remote repository ...")
Time.seconds(0.5).sleep
repos = phabricator.the_repository(repos.phid)
}
repos.ssh_url
case _ => error("Malformed remote specification " + quote(remote))
}
progress.echo("Remote repository " + quote(remote_url))
/* synchronize local and remote state */
progress.echo("Synchronizing ...")
edit_hgrc(local_hg, path_name, remote_url)
local_hg.pull(options = "-u")
local_hg.push(remote = remote_url)
}
val isabelle_tool =
Isabelle_Tool("hg_setup", "setup remote vs. local Mercurial repository",
Scala_Project.here, args =>
{
var remote_name = ""
var path_name = default_path_name
var remote_exists = false
val getopts = Getopts("""
Usage: isabelle hg_setup [OPTIONS] REMOTE LOCAL_DIR
Options are:
-n NAME remote repository name (default: base name of LOCAL_DIR)
-p PATH Mercurial path name (default: """ + quote(default_path_name) + """)
-r assume that remote repository already exists
Setup a remote vs. local Mercurial repository: REMOTE either refers to a
Phabricator server "user@host" or SSH file server "ssh://user@host/path".
""",
"n:" -> (arg => remote_name = arg),
"p:" -> (arg => path_name = arg),
"r" -> (_ => remote_exists = true))
val more_args = getopts(args)
val (remote, local_path) =
more_args match {
case List(arg1, arg2) => (arg1, Path.explode(arg2))
case _ => getopts.usage()
}
val progress = new Console_Progress
hg_setup(remote, local_path, remote_name = remote_name, path_name = path_name,
remote_exists = remote_exists, progress = progress)
})
}
diff --git a/src/Pure/General/multi_map.scala b/src/Pure/General/multi_map.scala
--- a/src/Pure/General/multi_map.scala
+++ b/src/Pure/General/multi_map.scala
@@ -1,91 +1,91 @@
/* Title: Pure/General/multi_map.scala
Author: Makarius
Maps with multiple entries per key.
*/
package isabelle
import scala.collection.mutable
import scala.collection.{IterableFactory, MapFactory, MapFactoryDefaults}
import scala.collection.immutable.{Iterable, MapOps}
object Multi_Map extends MapFactory[Multi_Map]
{
private val empty_val: Multi_Map[Any, Nothing] = new Multi_Map[Any, Nothing](Map.empty)
def empty[A, B]: Multi_Map[A, B] = empty_val.asInstanceOf[Multi_Map[A, B]]
def from[A, B](entries: IterableOnce[(A, B)]): Multi_Map[A, B] =
(empty[A, B] /: entries)({ case (m, (a, b)) => m.insert(a, b) })
override def newBuilder[A, B]: mutable.Builder[(A, B), Multi_Map[A, B]] = new Builder[A, B]
private class Builder[A, B] extends mutable.Builder[(A, B), Multi_Map[A, B]]
{
private var res = empty[A, B]
- override def clear() { res = empty[A, B] }
+ override def clear(): Unit = { res = empty[A, B] }
override def addOne(p: (A, B)): this.type = { res = res.insert(p._1, p._2); this }
override def result(): Multi_Map[A, B] = res
}
}
final class Multi_Map[A, +B] private(protected val rep: Map[A, List[B]])
extends Iterable[(A, B)]
with MapOps[A, B, Multi_Map, Multi_Map[A, B]]
with MapFactoryDefaults[A, B, Multi_Map, Iterable]
{
/* Multi_Map operations */
def iterator_list: Iterator[(A, List[B])] = rep.iterator
def get_list(a: A): List[B] = rep.getOrElse(a, Nil)
def insert[B1 >: B](a: A, b: B1): Multi_Map[A, B1] =
{
val bs = get_list(a)
if (bs.contains(b)) this
else new Multi_Map(rep + (a -> (b :: bs)))
}
def remove[B1 >: B](a: A, b: B1): Multi_Map[A, B1] =
{
val bs = get_list(a)
if (bs.contains(b)) {
bs.filterNot(_ == b) match {
case Nil => new Multi_Map(rep - a)
case bs1 => new Multi_Map(rep + (a -> bs1))
}
}
else this
}
def ++[B1 >: B] (other: Multi_Map[A, B1]): Multi_Map[A, B1] =
if (this eq other) this
else if (isEmpty) other
else
(this.asInstanceOf[Multi_Map[A, B1]] /: other.rep.iterator) {
case (m1, (a, bs)) => (bs :\ m1) { case (b, m2) => m2.insert(a, b) }
}
/* Map operations */
override def empty: Multi_Map[A, Nothing] = Multi_Map.empty
override def isEmpty: Boolean = rep.isEmpty
override def keySet: Set[A] = rep.keySet
override def iterator: Iterator[(A, B)] =
for ((a, bs) <- rep.iterator; b <- bs.iterator) yield (a, b)
def get(a: A): Option[B] = get_list(a).headOption
override def updated[B1 >: B](a: A, b: B1): Multi_Map[A, B1] = insert(a, b)
override def removed(a: A): Multi_Map[A, B] =
if (rep.isDefinedAt(a)) new Multi_Map(rep - a) else this
override def mapFactory: MapFactory[Multi_Map] = Multi_Map
override def toString: String = mkString("Multi_Map(", ", ", ")")
}
diff --git a/src/Pure/General/output.scala b/src/Pure/General/output.scala
--- a/src/Pure/General/output.scala
+++ b/src/Pure/General/output.scala
@@ -1,47 +1,47 @@
/* Title: Pure/General/output.scala
Author: Makarius
Isabelle output channels.
*/
package isabelle
object Output
{
def clean_yxml(msg: String): String =
try { XML.content(Protocol_Message.clean_reports(YXML.parse_body(msg))) }
catch { case ERROR(_) => msg }
def writeln_text(msg: String): String = clean_yxml(msg)
def warning_prefix(s: String): String = Library.prefix_lines("### ", s)
def warning_text(msg: String): String = warning_prefix(clean_yxml(msg))
def error_prefix(s: String): String = Library.prefix_lines("*** ", s)
def error_message_text(msg: String): String = error_prefix(clean_yxml(msg))
- def writeln(msg: String, stdout: Boolean = false, include_empty: Boolean = false)
+ def writeln(msg: String, stdout: Boolean = false, include_empty: Boolean = false): Unit =
{
if (msg.nonEmpty || include_empty) {
if (stdout) Console.print(writeln_text(msg) + "\n")
else Console.err.print(writeln_text(msg) + "\n")
}
}
- def warning(msg: String, stdout: Boolean = false, include_empty: Boolean = false)
+ def warning(msg: String, stdout: Boolean = false, include_empty: Boolean = false): Unit =
{
if (msg.nonEmpty || include_empty) {
if (stdout) Console.print(warning_text(msg) + "\n")
else Console.err.print(warning_text(msg) + "\n")
}
}
- def error_message(msg: String, stdout: Boolean = false, include_empty: Boolean = false)
+ def error_message(msg: String, stdout: Boolean = false, include_empty: Boolean = false): Unit =
{
if (msg.nonEmpty || include_empty) {
if (stdout) Console.print(error_message_text(msg) + "\n")
else Console.err.print(error_message_text(msg) + "\n")
}
}
}
diff --git a/src/Pure/General/path.scala b/src/Pure/General/path.scala
--- a/src/Pure/General/path.scala
+++ b/src/Pure/General/path.scala
@@ -1,306 +1,306 @@
/* Title: Pure/General/path.scala
Author: Makarius
Algebra of file-system paths: basic POSIX notation, extended by named
roots (e.g. //foo) and variables (e.g. $BAR).
*/
package isabelle
import java.io.{File => JFile}
import scala.util.matching.Regex
object Path
{
/* path elements */
sealed abstract class Elem
private case class Root(name: String) extends Elem
private case class Basic(name: String) extends Elem
private case class Variable(name: String) extends Elem
private case object Parent extends Elem
private def err_elem(msg: String, s: String): Nothing =
error(msg + " path element " + quote(s))
private val illegal_elem = Set("", "~", "~~", ".", "..")
private val illegal_char = "/\\$:\"'<>|?*"
private def check_elem(s: String): String =
if (illegal_elem.contains(s)) err_elem("Illegal", s)
else {
for (c <- s) {
if (c.toInt < 32)
err_elem("Illegal control character " + c.toInt + " in", s)
if (illegal_char.contains(c))
err_elem("Illegal character " + quote(c.toString) + " in", s)
}
s
}
private def root_elem(s: String): Elem = Root(check_elem(s))
private def basic_elem(s: String): Elem = Basic(check_elem(s))
private def variable_elem(s: String): Elem = Variable(check_elem(s))
private def apply_elem(y: Elem, xs: List[Elem]): List[Elem] =
(y, xs) match {
case (Root(_), _) => List(y)
case (Parent, Root(_) :: _) => xs
case (Parent, Basic(_) :: rest) => rest
case _ => y :: xs
}
private def norm_elems(elems: List[Elem]): List[Elem] =
(elems :\ (Nil: List[Elem]))(apply_elem)
private def implode_elem(elem: Elem, short: Boolean): String =
elem match {
case Root("") => ""
case Root(s) => "//" + s
case Basic(s) => s
case Variable("USER_HOME") if short => "~"
case Variable("ISABELLE_HOME") if short => "~~"
case Variable(s) => "$" + s
case Parent => ".."
}
private def squash_elem(elem: Elem): String =
elem match {
case Root("") => "ROOT"
case Root(s) => "SERVER_" + s
case Basic(s) => s
case Variable(s) => s
case Parent => "PARENT"
}
/* path constructors */
val current: Path = new Path(Nil)
val root: Path = new Path(List(Root("")))
def named_root(s: String): Path = new Path(List(root_elem(s)))
def make(elems: List[String]): Path = new Path(elems.reverse.map(basic_elem))
def basic(s: String): Path = new Path(List(basic_elem(s)))
def variable(s: String): Path = new Path(List(variable_elem(s)))
val parent: Path = new Path(List(Parent))
/* explode */
def explode(str: String): Path =
{
def explode_elem(s: String): Elem =
try {
if (s == "..") Parent
else if (s == "~") Variable("USER_HOME")
else if (s == "~~") Variable("ISABELLE_HOME")
else if (s.startsWith("$")) variable_elem(s.substring(1))
else basic_elem(s)
}
catch { case ERROR(msg) => cat_error(msg, "The error(s) above occurred in " + quote(str)) }
val ss = space_explode('/', str)
val r = ss.takeWhile(_.isEmpty).length
val es = ss.dropWhile(_.isEmpty)
val (roots, raw_elems) =
if (r == 0) (Nil, es)
else if (r == 1) (List(Root("")), es)
else if (es.isEmpty) (List(Root("")), Nil)
else (List(root_elem(es.head)), es.tail)
val elems = raw_elems.filterNot(s => s.isEmpty || s == ".").map(explode_elem)
new Path(norm_elems(elems reverse_::: roots))
}
def is_wellformed(str: String): Boolean =
try { explode(str); true } catch { case ERROR(_) => false }
def is_valid(str: String): Boolean =
try { explode(str).expand; true } catch { case ERROR(_) => false }
def split(str: String): List[Path] =
space_explode(':', str).filterNot(_.isEmpty).map(explode)
/* encode */
val encode: XML.Encode.T[Path] = (path => XML.Encode.string(path.implode))
/* reserved names */
private val reserved_windows: Set[String] =
Set("CON", "PRN", "AUX", "NUL",
"COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9",
"LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9")
def is_reserved(name: String): Boolean =
Long_Name.explode(name).exists(a => reserved_windows.contains(Word.uppercase(a)))
/* case-insensitive names */
- def check_case_insensitive(paths: List[Path])
+ def check_case_insensitive(paths: List[Path]): Unit =
{
val table =
(Multi_Map.empty[String, String] /: paths)({ case (tab, path) =>
val name = path.expand.implode
tab.insert(Word.lowercase(name), name)
})
val collisions =
(for { (_, coll) <- table.iterator_list if coll.length > 1 } yield coll).toList.flatten
if (collisions.nonEmpty) {
error(("Collision of file names due case-insensitivity:" :: collisions).mkString("\n "))
}
}
}
final class Path private(protected val elems: List[Path.Elem]) // reversed elements
{
override def hashCode: Int = elems.hashCode
override def equals(that: Any): Boolean =
that match {
case other: Path => elems == other.elems
case _ => false
}
def is_current: Boolean = elems.isEmpty
def is_absolute: Boolean = elems.nonEmpty && elems.last.isInstanceOf[Path.Root]
def is_root: Boolean = elems match { case List(Path.Root(_)) => true case _ => false }
def is_basic: Boolean = elems match { case List(Path.Basic(_)) => true case _ => false }
def starts_basic: Boolean = elems.nonEmpty && elems.last.isInstanceOf[Path.Basic]
def +(other: Path): Path = new Path((other.elems :\ elems)(Path.apply_elem))
/* implode */
private def gen_implode(short: Boolean): String =
elems match {
case Nil => "."
case List(Path.Root("")) => "/"
case _ => elems.map(Path.implode_elem(_, short)).reverse.mkString("/")
}
def implode: String = gen_implode(false)
def implode_short: String = gen_implode(true)
override def toString: String = quote(implode)
/* base element */
private def split_path: (Path, String) =
elems match {
case Path.Basic(s) :: xs => (new Path(xs), s)
case _ => error("Cannot split path into dir/base: " + toString)
}
def dir: Path = split_path._1
def base: Path = new Path(List(Path.Basic(split_path._2)))
def ext(e: String): Path =
if (e == "") this
else {
val (prfx, s) = split_path
prfx + Path.basic(s + "." + e)
}
def xz: Path = ext("xz")
def html: Path = ext("html")
def tex: Path = ext("tex")
def pdf: Path = ext("pdf")
def thy: Path = ext("thy")
def backup: Path =
{
val (prfx, s) = split_path
prfx + Path.basic(s + "~")
}
def backup2: Path =
{
val (prfx, s) = split_path
prfx + Path.basic(s + "~~")
}
def platform_exe: Path =
if (Platform.is_windows) ext("exe") else this
private val Ext = new Regex("(.*)\\.([^.]*)")
def split_ext: (Path, String) =
{
val (prefix, base) = split_path
base match {
case Ext(b, e) => (prefix + Path.basic(b), e)
case _ => (prefix + Path.basic(base), "")
}
}
def drop_ext: Path = split_ext._1
def get_ext: String = split_ext._2
def squash: Path = new Path(elems.map(elem => Path.Basic(Path.squash_elem(elem))))
/* expand */
def expand_env(env: Map[String, String]): Path =
{
def eval(elem: Path.Elem): List[Path.Elem] =
elem match {
case Path.Variable(s) =>
val path = Path.explode(Isabelle_System.getenv_strict(s, env))
if (path.elems.exists(_.isInstanceOf[Path.Variable]))
error("Illegal path variable nesting: " + s + "=" + path.toString)
else path.elems
case x => List(x)
}
new Path(Path.norm_elems(elems.flatMap(eval)))
}
def expand: Path = expand_env(Isabelle_System.settings())
def file_name: String = expand.base.implode
/* implode wrt. given directories */
def implode_symbolic: String =
{
val directories =
Library.space_explode(':', Isabelle_System.getenv("ISABELLE_DIRECTORIES")).reverse
val full_name = expand.implode
directories.view.flatMap(a =>
try {
val b = Path.explode(a).expand.implode
if (full_name == b) Some(a)
else {
Library.try_unprefix(b + "/", full_name) match {
case Some(name) => Some(a + "/" + name)
case None => None
}
}
} catch { case ERROR(_) => None }).headOption.getOrElse(implode)
}
def position: Position.T = Position.File(implode_symbolic)
/* platform files */
def file: JFile = File.platform_file(this)
def is_file: Boolean = file.isFile
def is_dir: Boolean = file.isDirectory
def absolute_file: JFile = File.absolute(file)
def canonical_file: JFile = File.canonical(file)
def absolute: Path = File.path(absolute_file)
def canonical: Path = File.path(canonical_file)
}
diff --git a/src/Pure/General/scan.scala b/src/Pure/General/scan.scala
--- a/src/Pure/General/scan.scala
+++ b/src/Pure/General/scan.scala
@@ -1,511 +1,511 @@
/* Title: Pure/General/scan.scala
Author: Makarius
Efficient scanning of keywords and tokens.
*/
package isabelle
import scala.annotation.tailrec
import scala.collection.{IndexedSeq, Traversable, TraversableOnce}
import scala.util.matching.Regex
import scala.util.parsing.input.{OffsetPosition, Position => InputPosition,
Reader, CharSequenceReader, PagedSeq}
import scala.util.parsing.combinator.RegexParsers
import java.io.{File => JFile, BufferedInputStream, FileInputStream, InputStream}
import java.net.URL
object Scan
{
/** context of partial line-oriented scans **/
abstract class Line_Context
case object Finished extends Line_Context
case class Quoted(quote: String) extends Line_Context
case object Verbatim extends Line_Context
case class Cartouche(depth: Int) extends Line_Context
case class Comment_Prefix(symbol: Symbol.Symbol) extends Line_Context
case class Cartouche_Comment(depth: Int) extends Line_Context
case class Comment(depth: Int) extends Line_Context
/** parser combinators **/
object Parsers extends Parsers
trait Parsers extends RegexParsers
{
override val whiteSpace: Regex = "".r
/* optional termination */
def opt_term[T](p: => Parser[T]): Parser[Option[T]] =
p ^^ (x => Some(x)) | """\z""".r ^^ (_ => None)
/* repeated symbols */
def repeated(pred: Symbol.Symbol => Boolean, min_count: Int, max_count: Int): Parser[String] =
new Parser[String]
{
def apply(in: Input) =
{
val start = in.offset
val end = in.source.length
val matcher = new Symbol.Matcher(in.source)
var i = start
var count = 0
var finished = false
while (!finished && i < end && count < max_count) {
val n = matcher(i, end)
val sym = in.source.subSequence(i, i + n).toString
if (pred(sym)) { i += n; count += 1 }
else finished = true
}
if (count < min_count) Failure("bad input", in)
else Success(in.source.subSequence(start, i).toString, in.drop(i - start))
}
}.named("repeated")
def one(pred: Symbol.Symbol => Boolean): Parser[String] =
repeated(pred, 1, 1)
def maybe(pred: Symbol.Symbol => Boolean): Parser[String] =
repeated(pred, 0, 1)
def many(pred: Symbol.Symbol => Boolean): Parser[String] =
repeated(pred, 0, Integer.MAX_VALUE)
def many1(pred: Symbol.Symbol => Boolean): Parser[String] =
repeated(pred, 1, Integer.MAX_VALUE)
/* character */
def character(pred: Char => Boolean): Symbol.Symbol => Boolean =
(s: Symbol. Symbol) => s.length == 1 && pred(s.charAt(0))
/* quoted strings */
private def quoted_body(quote: Symbol.Symbol): Parser[String] =
{
rep(many1(sym => sym != quote && sym != "\\") | "\\" + quote | "\\\\" |
("""\\\d\d\d""".r ^? { case x if x.substring(1, 4).toInt <= 255 => x })) ^^ (_.mkString)
}
def quoted(quote: Symbol.Symbol): Parser[String] =
{
quote ~ quoted_body(quote) ~ quote ^^ { case x ~ y ~ z => x + y + z }
}.named("quoted")
def quoted_content(quote: Symbol.Symbol, source: String): String =
{
require(parseAll(quoted(quote), source).successful, "no quoted text")
val body = source.substring(1, source.length - 1)
if (body.exists(_ == '\\')) {
val content =
rep(many1(sym => sym != quote && sym != "\\") |
"\\" ~> (quote | "\\" | """\d\d\d""".r ^^ { case x => x.toInt.toChar.toString }))
parseAll(content ^^ (_.mkString), body).get
}
else body
}
def quoted_line(quote: Symbol.Symbol, ctxt: Line_Context): Parser[(String, Line_Context)] =
{
ctxt match {
case Finished =>
quote ~ quoted_body(quote) ~ opt_term(quote) ^^
{ case x ~ y ~ Some(z) => (x + y + z, Finished)
case x ~ y ~ None => (x + y, Quoted(quote)) }
case Quoted(q) if q == quote =>
quoted_body(quote) ~ opt_term(quote) ^^
{ case x ~ Some(y) => (x + y, Finished)
case x ~ None => (x, ctxt) }
case _ => failure("")
}
}.named("quoted_line")
def recover_quoted(quote: Symbol.Symbol): Parser[String] =
quote ~ quoted_body(quote) ^^ { case x ~ y => x + y }
/* verbatim text */
private def verbatim_body: Parser[String] =
rep(many1(sym => sym != "*") | """\*(?!\})""".r) ^^ (_.mkString)
def verbatim: Parser[String] =
{
"{*" ~ verbatim_body ~ "*}" ^^ { case x ~ y ~ z => x + y + z }
}.named("verbatim")
def verbatim_content(source: String): String =
{
require(parseAll(verbatim, source).successful, "no verbatim text")
source.substring(2, source.length - 2)
}
def verbatim_line(ctxt: Line_Context): Parser[(String, Line_Context)] =
{
ctxt match {
case Finished =>
"{*" ~ verbatim_body ~ opt_term("*}") ^^
{ case x ~ y ~ Some(z) => (x + y + z, Finished)
case x ~ y ~ None => (x + y, Verbatim) }
case Verbatim =>
verbatim_body ~ opt_term("*}") ^^
{ case x ~ Some(y) => (x + y, Finished)
case x ~ None => (x, Verbatim) }
case _ => failure("")
}
}.named("verbatim_line")
val recover_verbatim: Parser[String] =
"{*" ~ verbatim_body ^^ { case x ~ y => x + y }
/* nested text cartouches */
def cartouche_depth(depth: Int): Parser[(String, Int)] = new Parser[(String, Int)]
{
require(depth >= 0, "bad cartouche depth")
def apply(in: Input) =
{
val start = in.offset
val end = in.source.length
val matcher = new Symbol.Matcher(in.source)
var i = start
var d = depth
var finished = false
while (!finished && i < end) {
val n = matcher(i, end)
val sym = in.source.subSequence(i, i + n).toString
if (Symbol.is_open(sym)) { i += n; d += 1 }
else if (Symbol.is_close(sym) && d > 0) { i += n; d -= 1; if (d == 0) finished = true }
else if (d > 0) i += n
else finished = true
}
if (i == start) Failure("bad input", in)
else Success((in.source.subSequence(start, i).toString, d), in.drop(i - start))
}
}.named("cartouche_depth")
def cartouche: Parser[String] =
cartouche_depth(0) ^? { case (x, d) if d == 0 => x }
def cartouche_line(ctxt: Line_Context): Parser[(String, Line_Context)] =
{
def cartouche_context(d: Int): Line_Context =
if (d == 0) Finished else Cartouche(d)
ctxt match {
case Finished =>
cartouche_depth(0) ^^ { case (c, d) => (c, cartouche_context(d)) }
case Cartouche(depth) =>
cartouche_depth(depth) ^^ { case (c, d) => (c, cartouche_context(d)) }
case _ => failure("")
}
}
val recover_cartouche: Parser[String] =
cartouche_depth(0) ^^ (_._1)
def cartouche_content(source: String): String =
{
def err(): Nothing = error("Malformed text cartouche: " + quote(source))
val source1 =
Library.try_unprefix(Symbol.open_decoded, source) orElse
Library.try_unprefix(Symbol.open, source) getOrElse err()
Library.try_unsuffix(Symbol.close_decoded, source1) orElse
Library.try_unsuffix(Symbol.close, source1) getOrElse err()
}
/* nested comments */
private def comment_depth(depth: Int): Parser[(String, Int)] = new Parser[(String, Int)]
{
require(depth >= 0, "bad comment depth")
val comment_text: Parser[List[String]] =
rep1(many1(sym => sym != "*" && sym != "(") | """\*(?!\))|\((?!\*)""".r)
def apply(in: Input) =
{
var rest = in
def try_parse[A](p: Parser[A]): Boolean =
{
parse(p ^^^ (()), rest) match {
case Success(_, next) => { rest = next; true }
case _ => false
}
}
var d = depth
var finished = false
while (!finished) {
if (try_parse("(*")) d += 1
else if (d > 0 && try_parse("*)")) { d -= 1; if (d == 0) finished = true }
else if (d == 0 || !try_parse(comment_text)) finished = true
}
if (in.offset < rest.offset)
Success((in.source.subSequence(in.offset, rest.offset).toString, d), rest)
else Failure("comment expected", in)
}
}.named("comment_depth")
def comment: Parser[String] =
comment_depth(0) ^? { case (x, d) if d == 0 => x }
def comment_line(ctxt: Line_Context): Parser[(String, Line_Context)] =
{
val depth =
ctxt match {
case Finished => 0
case Comment(d) => d
case _ => -1
}
if (depth >= 0)
comment_depth(depth) ^^
{ case (x, 0) => (x, Finished)
case (x, d) => (x, Comment(d)) }
else failure("")
}
val recover_comment: Parser[String] =
comment_depth(0) ^^ (_._1)
def comment_content(source: String): String =
{
require(parseAll(comment, source).successful, "no comment")
source.substring(2, source.length - 2)
}
/* keyword */
def literal(lexicon: Lexicon): Parser[String] = new Parser[String]
{
def apply(in: Input) =
{
val result = lexicon.scan(in)
if (result.isEmpty) Failure("keyword expected", in)
else Success(result, in.drop(result.length))
}
}.named("keyword")
}
/** Lexicon -- position tree **/
object Lexicon
{
/* representation */
private sealed case class Tree(branches: Map[Char, (String, Tree)])
private val empty_tree = Tree(Map())
val empty: Lexicon = new Lexicon(empty_tree)
def apply(elems: String*): Lexicon = empty ++ elems
}
final class Lexicon private(rep: Lexicon.Tree)
{
/* auxiliary operations */
private def dest(tree: Lexicon.Tree, result: List[String]): List[String] =
(result /: tree.branches.toList) ((res, entry) =>
entry match { case (_, (s, tr)) =>
if (s.isEmpty) dest(tr, res) else dest(tr, s :: res) })
private def lookup(str: CharSequence): Option[(Boolean, Lexicon.Tree)] =
{
val len = str.length
@tailrec def look(tree: Lexicon.Tree, tip: Boolean, i: Int): Option[(Boolean, Lexicon.Tree)] =
{
if (i < len) {
tree.branches.get(str.charAt(i)) match {
case Some((s, tr)) => look(tr, s.nonEmpty, i + 1)
case None => None
}
}
else Some(tip, tree)
}
look(rep, false, 0)
}
def completions(str: CharSequence): List[String] =
lookup(str) match {
case Some((true, tree)) => dest(tree, List(str.toString))
case Some((false, tree)) => dest(tree, Nil)
case None => Nil
}
/* pseudo Set methods */
def raw_iterator: Iterator[String] = dest(rep, Nil).iterator
def iterator: Iterator[String] = dest(rep, Nil).sorted.iterator
override def toString: String = iterator.mkString("Lexicon(", ", ", ")")
def is_empty: Boolean = rep.branches.isEmpty
def contains(elem: String): Boolean =
lookup(elem) match {
case Some((tip, _)) => tip
case _ => false
}
/* build lexicon */
def + (elem: String): Lexicon =
if (contains(elem)) this
else {
val len = elem.length
def extend(tree: Lexicon.Tree, i: Int): Lexicon.Tree =
if (i < len) {
val c = elem.charAt(i)
val end = (i + 1 == len)
tree.branches.get(c) match {
case Some((s, tr)) =>
Lexicon.Tree(tree.branches +
(c -> (if (end) elem else s, extend(tr, i + 1))))
case None =>
Lexicon.Tree(tree.branches +
(c -> (if (end) elem else "", extend(Lexicon.empty_tree, i + 1))))
}
}
else tree
new Lexicon(extend(rep, 0))
}
def ++ (elems: TraversableOnce[String]): Lexicon = (this /: elems)(_ + _)
def ++ (other: Lexicon): Lexicon =
if (this eq other) this
else if (is_empty) other
else this ++ other.raw_iterator
def -- (remove: Traversable[String]): Lexicon =
if (remove.exists(contains))
Lexicon.empty ++ iterator.filterNot(a => remove.exists(b => a == b))
else this
/* scan */
def scan(in: Reader[Char]): String =
{
val source = in.source
val offset = in.offset
val len = source.length - offset
@tailrec def scan_tree(tree: Lexicon.Tree, result: String, i: Int): String =
{
if (i < len) {
tree.branches.get(source.charAt(offset + i)) match {
case Some((s, tr)) => scan_tree(tr, if (s.isEmpty) result else s, i + 1)
case None => result
}
}
else result
}
scan_tree(rep, "", 0)
}
}
/** read stream without decoding: efficient length operation **/
private class Restricted_Seq(seq: IndexedSeq[Char], start: Int, end: Int)
extends CharSequence
{
def charAt(i: Int): Char =
if (0 <= i && i < length) seq(start + i)
else throw new IndexOutOfBoundsException
def length: Int = end - start // avoid expensive seq.length
def subSequence(i: Int, j: Int): CharSequence =
if (0 <= i && i <= j && j <= length) new Restricted_Seq(seq, start + i, start + j)
else throw new IndexOutOfBoundsException
override def toString: String =
{
val buf = new StringBuilder(length)
for (offset <- start until end) buf.append(seq(offset))
buf.toString
}
}
abstract class Byte_Reader extends Reader[Char] with AutoCloseable
private def make_byte_reader(stream: InputStream, stream_length: Int): Byte_Reader =
{
val buffered_stream = new BufferedInputStream(stream)
val seq = new PagedSeq(
(buf: Array[Char], offset: Int, length: Int) =>
{
var i = 0
var c = 0
var eof = false
while (!eof && i < length) {
c = buffered_stream.read
if (c == -1) eof = true
else { buf(offset + i) = c.toChar; i += 1 }
}
if (i > 0) i else -1
})
val restricted_seq = new Restricted_Seq(seq, 0, stream_length)
class Paged_Reader(override val offset: Int) extends Byte_Reader
{
override lazy val source: CharSequence = restricted_seq
def first: Char = if (seq.isDefinedAt(offset)) seq(offset) else '\u001a'
def rest: Paged_Reader = if (seq.isDefinedAt(offset)) new Paged_Reader(offset + 1) else this
def pos: InputPosition = new OffsetPosition(source, offset)
def atEnd: Boolean = !seq.isDefinedAt(offset)
override def drop(n: Int): Paged_Reader = new Paged_Reader(offset + n)
- def close { buffered_stream.close }
+ def close: Unit = buffered_stream.close
}
new Paged_Reader(0)
}
def byte_reader(file: JFile): Byte_Reader =
make_byte_reader(new FileInputStream(file), file.length.toInt)
def byte_reader(url: URL): Byte_Reader =
{
val connection = url.openConnection
val stream = connection.getInputStream
val stream_length = connection.getContentLength
make_byte_reader(stream, stream_length)
}
def reader_is_utf8(reader: Reader[Char]): Boolean =
reader.isInstanceOf[Byte_Reader]
def reader_decode_utf8(is_utf8: Boolean, s: String): String =
if (is_utf8) UTF8.decode_permissive(s) else s
def reader_decode_utf8(reader: Reader[Char], s: String): String =
reader_decode_utf8(reader_is_utf8(reader), s)
/* plain text reader */
def char_reader(text: CharSequence): CharSequenceReader =
new CharSequenceReader(text)
}
diff --git a/src/Pure/General/sql.scala b/src/Pure/General/sql.scala
--- a/src/Pure/General/sql.scala
+++ b/src/Pure/General/sql.scala
@@ -1,514 +1,514 @@
/* Title: Pure/General/sql.scala
Author: Makarius
Support for SQL databases: SQLite and PostgreSQL.
*/
package isabelle
import java.time.OffsetDateTime
import java.sql.{DriverManager, Connection, PreparedStatement, ResultSet}
import scala.collection.mutable
object SQL
{
/** SQL language **/
type Source = String
/* concrete syntax */
def escape_char(c: Char): String =
c match {
case '\u0000' => "\\0"
case '\'' => "\\'"
case '\"' => "\\\""
case '\b' => "\\b"
case '\n' => "\\n"
case '\r' => "\\r"
case '\t' => "\\t"
case '\u001a' => "\\Z"
case '\\' => "\\\\"
case _ => c.toString
}
def string(s: String): Source =
s.iterator.map(escape_char).mkString("'", "", "'")
def ident(s: String): Source =
Long_Name.implode(Long_Name.explode(s).map(a => quote(a.replace("\"", "\"\""))))
def enclose(s: Source): Source = "(" + s + ")"
def enclosure(ss: Iterable[Source]): Source = ss.mkString("(", ", ", ")")
def select(columns: List[Column] = Nil, distinct: Boolean = false): Source =
"SELECT " + (if (distinct) "DISTINCT " else "") +
(if (columns.isEmpty) "*" else commas(columns.map(_.ident))) + " FROM "
val join_outer: Source = " LEFT OUTER JOIN "
val join_inner: Source = " INNER JOIN "
def join(outer: Boolean): Source = if (outer) join_outer else join_inner
def member(x: Source, set: Iterable[String]): Source =
set.iterator.map(a => x + " = " + SQL.string(a)).mkString("(", " OR ", ")")
/* types */
object Type extends Enumeration
{
val Boolean = Value("BOOLEAN")
val Int = Value("INTEGER")
val Long = Value("BIGINT")
val Double = Value("DOUBLE PRECISION")
val String = Value("TEXT")
val Bytes = Value("BLOB")
val Date = Value("TIMESTAMP WITH TIME ZONE")
}
def sql_type_default(T: Type.Value): Source = T.toString
def sql_type_sqlite(T: Type.Value): Source =
if (T == Type.Boolean) "INTEGER"
else if (T == Type.Date) "TEXT"
else sql_type_default(T)
def sql_type_postgresql(T: Type.Value): Source =
if (T == Type.Bytes) "BYTEA"
else sql_type_default(T)
/* columns */
object Column
{
def bool(name: String, strict: Boolean = false, primary_key: Boolean = false): Column =
Column(name, Type.Boolean, strict, primary_key)
def int(name: String, strict: Boolean = false, primary_key: Boolean = false): Column =
Column(name, Type.Int, strict, primary_key)
def long(name: String, strict: Boolean = false, primary_key: Boolean = false): Column =
Column(name, Type.Long, strict, primary_key)
def double(name: String, strict: Boolean = false, primary_key: Boolean = false): Column =
Column(name, Type.Double, strict, primary_key)
def string(name: String, strict: Boolean = false, primary_key: Boolean = false): Column =
Column(name, Type.String, strict, primary_key)
def bytes(name: String, strict: Boolean = false, primary_key: Boolean = false): Column =
Column(name, Type.Bytes, strict, primary_key)
def date(name: String, strict: Boolean = false, primary_key: Boolean = false): Column =
Column(name, Type.Date, strict, primary_key)
}
sealed case class Column(
name: String, T: Type.Value, strict: Boolean = false, primary_key: Boolean = false,
expr: SQL.Source = "")
{
def make_primary_key: Column = copy(primary_key = true)
def apply(table: Table): Column =
Column(Long_Name.qualify(table.name, name), T, strict = strict, primary_key = primary_key)
def ident: Source =
if (expr == "") SQL.ident(name)
else enclose(expr) + " AS " + SQL.ident(name)
def decl(sql_type: Type.Value => Source): Source =
ident + " " + sql_type(T) + (if (strict || primary_key) " NOT NULL" else "")
def defined: String = ident + " IS NOT NULL"
def undefined: String = ident + " IS NULL"
def equal(s: String): Source = ident + " = " + string(s)
def where_equal(s: String): Source = "WHERE " + equal(s)
override def toString: Source = ident
}
/* tables */
sealed case class Table(name: String, columns: List[Column], body: Source = "")
{
private val columns_index: Map[String, Int] =
columns.iterator.map(_.name).zipWithIndex.toMap
Library.duplicates(columns.map(_.name)) match {
case Nil =>
case bad => error("Duplicate column names " + commas_quote(bad) + " for table " + quote(name))
}
def ident: Source = SQL.ident(name)
def query: Source =
if (body == "") error("Missing SQL body for table " + quote(name))
else SQL.enclose(body)
def query_named: Source = query + " AS " + SQL.ident(name)
def create(strict: Boolean = false, sql_type: Type.Value => Source): Source =
{
val primary_key =
columns.filter(_.primary_key).map(_.name) match {
case Nil => Nil
case keys => List("PRIMARY KEY " + enclosure(keys))
}
"CREATE TABLE " + (if (strict) "" else "IF NOT EXISTS ") +
ident + " " + enclosure(columns.map(_.decl(sql_type)) ::: primary_key)
}
def create_index(index_name: String, index_columns: List[Column],
strict: Boolean = false, unique: Boolean = false): Source =
"CREATE " + (if (unique) "UNIQUE " else "") + "INDEX " +
(if (strict) "" else "IF NOT EXISTS ") + SQL.ident(index_name) + " ON " +
ident + " " + enclosure(index_columns.map(_.name))
def insert_cmd(cmd: Source, sql: Source = ""): Source =
cmd + " INTO " + ident + " VALUES " + enclosure(columns.map(_ => "?")) +
(if (sql == "") "" else " " + sql)
def insert(sql: Source = ""): Source = insert_cmd("INSERT", sql)
def delete(sql: Source = ""): Source =
"DELETE FROM " + ident +
(if (sql == "") "" else " " + sql)
def select(
select_columns: List[Column] = Nil, sql: Source = "", distinct: Boolean = false): Source =
SQL.select(select_columns, distinct = distinct) + ident +
(if (sql == "") "" else " " + sql)
override def toString: Source = ident
}
/** SQL database operations **/
/* statements */
class Statement private[SQL](val db: Database, val rep: PreparedStatement)
extends AutoCloseable
{
stmt =>
object bool
{
- def update(i: Int, x: Boolean) { rep.setBoolean(i, x) }
- def update(i: Int, x: Option[Boolean])
+ def update(i: Int, x: Boolean): Unit = rep.setBoolean(i, x)
+ def update(i: Int, x: Option[Boolean]): Unit =
{
if (x.isDefined) update(i, x.get)
else rep.setNull(i, java.sql.Types.BOOLEAN)
}
}
object int
{
- def update(i: Int, x: Int) { rep.setInt(i, x) }
- def update(i: Int, x: Option[Int])
+ def update(i: Int, x: Int): Unit = rep.setInt(i, x)
+ def update(i: Int, x: Option[Int]): Unit =
{
if (x.isDefined) update(i, x.get)
else rep.setNull(i, java.sql.Types.INTEGER)
}
}
object long
{
- def update(i: Int, x: Long) { rep.setLong(i, x) }
- def update(i: Int, x: Option[Long])
+ def update(i: Int, x: Long): Unit = rep.setLong(i, x)
+ def update(i: Int, x: Option[Long]): Unit =
{
if (x.isDefined) update(i, x.get)
else rep.setNull(i, java.sql.Types.BIGINT)
}
}
object double
{
- def update(i: Int, x: Double) { rep.setDouble(i, x) }
- def update(i: Int, x: Option[Double])
+ def update(i: Int, x: Double): Unit = rep.setDouble(i, x)
+ def update(i: Int, x: Option[Double]): Unit =
{
if (x.isDefined) update(i, x.get)
else rep.setNull(i, java.sql.Types.DOUBLE)
}
}
object string
{
- def update(i: Int, x: String) { rep.setString(i, x) }
+ def update(i: Int, x: String): Unit = rep.setString(i, x)
def update(i: Int, x: Option[String]): Unit = update(i, x.orNull)
}
object bytes
{
- def update(i: Int, bytes: Bytes)
+ def update(i: Int, bytes: Bytes): Unit =
{
if (bytes == null) rep.setBytes(i, null)
else rep.setBinaryStream(i, bytes.stream(), bytes.length)
}
def update(i: Int, bytes: Option[Bytes]): Unit = update(i, bytes.orNull)
}
object date
{
def update(i: Int, date: Date): Unit = db.update_date(stmt, i, date)
def update(i: Int, date: Option[Date]): Unit = update(i, date.orNull)
}
def execute(): Boolean = rep.execute()
def execute_query(): Result = new Result(this, rep.executeQuery())
def close(): Unit = rep.close
}
/* results */
class Result private[SQL](val stmt: Statement, val rep: ResultSet)
{
res =>
def next(): Boolean = rep.next()
def iterator[A](get: Result => A): Iterator[A] = new Iterator[A]
{
private var _next: Boolean = res.next()
def hasNext: Boolean = _next
def next(): A = { val x = get(res); _next = res.next(); x }
}
def bool(column: Column): Boolean = rep.getBoolean(column.name)
def int(column: Column): Int = rep.getInt(column.name)
def long(column: Column): Long = rep.getLong(column.name)
def double(column: Column): Double = rep.getDouble(column.name)
def string(column: Column): String =
{
val s = rep.getString(column.name)
if (s == null) "" else s
}
def bytes(column: Column): Bytes =
{
val bs = rep.getBytes(column.name)
if (bs == null) Bytes.empty else Bytes(bs)
}
def date(column: Column): Date = stmt.db.date(res, column)
def timing(c1: Column, c2: Column, c3: Column): Timing =
Timing(Time.ms(long(c1)), Time.ms(long(c2)), Time.ms(long(c3)))
def get[A](column: Column, f: Column => A): Option[A] =
{
val x = f(column)
if (rep.wasNull) None else Some(x)
}
def get_bool(column: Column): Option[Boolean] = get(column, bool)
def get_int(column: Column): Option[Int] = get(column, int)
def get_long(column: Column): Option[Long] = get(column, long)
def get_double(column: Column): Option[Double] = get(column, double)
def get_string(column: Column): Option[String] = get(column, string)
def get_bytes(column: Column): Option[Bytes] = get(column, bytes)
def get_date(column: Column): Option[Date] = get(column, date)
}
/* database */
trait Database extends AutoCloseable
{
db =>
/* types */
def sql_type(T: Type.Value): Source
/* connection */
def connection: Connection
- def close() { connection.close }
+ def close(): Unit = connection.close
def transaction[A](body: => A): A =
{
val auto_commit = connection.getAutoCommit
try {
connection.setAutoCommit(false)
val savepoint = connection.setSavepoint
try {
val result = body
connection.commit
result
}
catch { case exn: Throwable => connection.rollback(savepoint); throw exn }
}
finally { connection.setAutoCommit(auto_commit) }
}
/* statements and results */
def statement(sql: Source): Statement =
new Statement(db, connection.prepareStatement(sql))
def using_statement[A](sql: Source)(f: Statement => A): A =
using(statement(sql))(f)
def update_date(stmt: Statement, i: Int, date: Date): Unit
def date(res: Result, column: Column): Date
def insert_permissive(table: Table, sql: Source = ""): Source
/* tables and views */
def tables: List[String] =
{
val result = new mutable.ListBuffer[String]
val rs = connection.getMetaData.getTables(null, null, "%", null)
while (rs.next) { result += rs.getString(3) }
result.toList
}
def create_table(table: Table, strict: Boolean = false, sql: Source = ""): Unit =
using_statement(
table.create(strict, sql_type) + (if (sql == "") "" else " " + sql))(_.execute())
def create_index(table: Table, name: String, columns: List[Column],
strict: Boolean = false, unique: Boolean = false): Unit =
using_statement(table.create_index(name, columns, strict, unique))(_.execute())
def create_view(table: Table, strict: Boolean = false): Unit =
{
if (strict || !tables.contains(table.name)) {
val sql = "CREATE VIEW " + table + " AS " + { table.query; table.body }
using_statement(sql)(_.execute())
}
}
}
}
/** SQLite **/
object SQLite
{
// see https://www.sqlite.org/lang_datefunc.html
val date_format: Date.Format = Date.Format("uuuu-MM-dd HH:mm:ss.SSS x")
lazy val init_jdbc: Unit =
{
val lib_path = Path.explode("$ISABELLE_SQLITE_HOME/" + Platform.jvm_platform)
val lib_name =
File.find_files(lib_path.file) match {
case List(file) => file.getName
case _ => error("Exactly one file expected in directory " + lib_path.expand)
}
System.setProperty("org.sqlite.lib.path", File.platform_path(lib_path))
System.setProperty("org.sqlite.lib.name", lib_name)
Class.forName("org.sqlite.JDBC")
}
def open_database(path: Path): Database =
{
init_jdbc
val path0 = path.expand
val s0 = File.platform_path(path0)
val s1 = if (Platform.is_windows) s0.replace('\\', '/') else s0
val connection = DriverManager.getConnection("jdbc:sqlite:" + s1)
new Database(path0.toString, connection)
}
class Database private[SQLite](name: String, val connection: Connection) extends SQL.Database
{
override def toString: String = name
def sql_type(T: SQL.Type.Value): SQL.Source = SQL.sql_type_sqlite(T)
def update_date(stmt: SQL.Statement, i: Int, date: Date): Unit =
if (date == null) stmt.string(i) = (null: String)
else stmt.string(i) = date_format(date)
def date(res: SQL.Result, column: SQL.Column): Date =
date_format.parse(res.string(column))
def insert_permissive(table: SQL.Table, sql: SQL.Source = ""): SQL.Source =
table.insert_cmd("INSERT OR IGNORE", sql = sql)
- def rebuild { using_statement("VACUUM")(_.execute()) }
+ def rebuild: Unit = using_statement("VACUUM")(_.execute())
}
}
/** PostgreSQL **/
object PostgreSQL
{
val default_port = 5432
lazy val init_jdbc: Unit = Class.forName("org.postgresql.Driver")
def open_database(
user: String,
password: String,
database: String = "",
host: String = "",
port: Int = 0,
ssh: Option[SSH.Session] = None,
ssh_close: Boolean = false): Database =
{
init_jdbc
if (user == "") error("Undefined database user")
val db_host = proper_string(host) getOrElse "localhost"
val db_port = if (port > 0 && port != default_port) ":" + port else ""
val db_name = "/" + (proper_string(database) getOrElse user)
val (url, name, port_forwarding) =
ssh match {
case None =>
val spec = db_host + db_port + db_name
val url = "jdbc:postgresql://" + spec
val name = user + "@" + spec
(url, name, None)
case Some(ssh) =>
val fw =
ssh.port_forwarding(remote_host = db_host,
remote_port = if (port > 0) port else default_port,
ssh_close = ssh_close)
val url = "jdbc:postgresql://localhost:" + fw.local_port + db_name
val name = user + "@" + fw + db_name + " via ssh " + ssh
(url, name, Some(fw))
}
try {
val connection = DriverManager.getConnection(url, user, password)
new Database(name, connection, port_forwarding)
}
catch { case exn: Throwable => port_forwarding.foreach(_.close); throw exn }
}
class Database private[PostgreSQL](
name: String, val connection: Connection, port_forwarding: Option[SSH.Port_Forwarding])
extends SQL.Database
{
override def toString: String = name
def sql_type(T: SQL.Type.Value): SQL.Source = SQL.sql_type_postgresql(T)
// see https://jdbc.postgresql.org/documentation/head/8-date-time.html
def update_date(stmt: SQL.Statement, i: Int, date: Date): Unit =
if (date == null) stmt.rep.setObject(i, null)
else stmt.rep.setObject(i, OffsetDateTime.from(date.to(Date.timezone_utc).rep))
def date(res: SQL.Result, column: SQL.Column): Date =
{
val obj = res.rep.getObject(column.name, classOf[OffsetDateTime])
if (obj == null) null else Date.instant(obj.toInstant)
}
def insert_permissive(table: SQL.Table, sql: SQL.Source = ""): SQL.Source =
table.insert_cmd("INSERT",
sql = sql + (if (sql == "") "" else " ") + "ON CONFLICT DO NOTHING")
- override def close() { super.close; port_forwarding.foreach(_.close) }
+ override def close(): Unit = { super.close; port_forwarding.foreach(_.close) }
}
}
diff --git a/src/Pure/General/ssh.scala b/src/Pure/General/ssh.scala
--- a/src/Pure/General/ssh.scala
+++ b/src/Pure/General/ssh.scala
@@ -1,513 +1,513 @@
/* Title: Pure/General/ssh.scala
Author: Makarius
SSH client based on JSch (see also http://www.jcraft.com/jsch/examples).
*/
package isabelle
import java.io.{InputStream, OutputStream, ByteArrayOutputStream}
import scala.collection.mutable
import scala.util.matching.Regex
import com.jcraft.jsch.{JSch, Logger => JSch_Logger, Session => JSch_Session, SftpException,
OpenSSHConfig, UserInfo, Channel => JSch_Channel, ChannelExec, ChannelSftp, SftpATTRS,
JSchException}
object SSH
{
/* target machine: user@host syntax */
object Target
{
val User_Host: Regex = "^([^@]+)@(.+)$".r
def parse(s: String): (String, String) =
s match {
case User_Host(user, host) => (user, host)
case _ => ("", s)
}
def unapplySeq(s: String): Option[List[String]] =
parse(s) match {
case (_, "") => None
case (user, host) => Some(List(user, host))
}
}
val default_port = 22
def make_port(port: Int): Int = if (port > 0) port else default_port
def port_suffix(port: Int): String =
if (port == default_port) "" else ":" + port
def user_prefix(user: String): String =
proper_string(user) match {
case None => ""
case Some(name) => name + "@"
}
def connect_timeout(options: Options): Int =
options.seconds("ssh_connect_timeout").ms.toInt
def alive_interval(options: Options): Int =
options.seconds("ssh_alive_interval").ms.toInt
def alive_count_max(options: Options): Int =
options.int("ssh_alive_count_max")
/* init context */
def init_context(options: Options): Context =
{
val config_dir = Path.explode(options.string("ssh_config_dir"))
if (!config_dir.is_dir) error("Bad ssh config directory: " + config_dir)
val jsch = new JSch
val config_file = Path.explode(options.string("ssh_config_file"))
if (config_file.is_file)
jsch.setConfigRepository(OpenSSHConfig.parseFile(File.platform_path(config_file)))
val known_hosts = config_dir + Path.explode("known_hosts")
if (!known_hosts.is_file) known_hosts.file.createNewFile
jsch.setKnownHosts(File.platform_path(known_hosts))
val identity_files =
space_explode(':', options.string("ssh_identity_files")).map(Path.explode)
for (identity_file <- identity_files if identity_file.is_file) {
try { jsch.addIdentity(File.platform_path(identity_file)) }
catch {
case exn: JSchException =>
error("Error in ssh identity file " + identity_file + ": " + exn.getMessage)
}
}
new Context(options, jsch)
}
def open_session(options: Options,
host: String, user: String = "", port: Int = 0, actual_host: String = "",
proxy_host: String = "", proxy_user: String = "", proxy_port: Int = 0,
permissive: Boolean = false): Session =
init_context(options).open_session(
host = host, user = user, port = port, actual_host = actual_host,
proxy_host = proxy_host, proxy_user = proxy_user, proxy_port = proxy_port,
permissive = permissive)
class Context private[SSH](val options: Options, val jsch: JSch)
{
def update_options(new_options: Options): Context = new Context(new_options, jsch)
private def connect_session(host: String, user: String = "", port: Int = 0,
host_key_permissive: Boolean = false,
nominal_host: String = "",
nominal_user: String = "",
on_close: () => Unit = () => ()): Session =
{
val session = jsch.getSession(proper_string(user).orNull, host, make_port(port))
session.setUserInfo(No_User_Info)
session.setServerAliveInterval(alive_interval(options))
session.setServerAliveCountMax(alive_count_max(options))
session.setConfig("MaxAuthTries", "3")
if (host_key_permissive) session.setConfig("StrictHostKeyChecking", "no")
if (nominal_host != "") session.setHostKeyAlias(nominal_host)
if (options.bool("ssh_compression")) {
session.setConfig("compression.s2c", "zlib@openssh.com,zlib,none")
session.setConfig("compression.c2s", "zlib@openssh.com,zlib,none")
session.setConfig("compression_level", "9")
}
session.connect(connect_timeout(options))
new Session(options, session, on_close,
proper_string(nominal_host) getOrElse host,
proper_string(nominal_user) getOrElse user)
}
def open_session(
host: String, user: String = "", port: Int = 0, actual_host: String = "",
proxy_host: String = "", proxy_user: String = "", proxy_port: Int = 0,
permissive: Boolean = false): Session =
{
val connect_host = proper_string(actual_host) getOrElse host
if (proxy_host == "") connect_session(host = connect_host, user = user, port = port)
else {
val proxy = connect_session(host = proxy_host, port = proxy_port, user = proxy_user)
val fw =
try { proxy.port_forwarding(remote_host = connect_host, remote_port = make_port(port)) }
catch { case exn: Throwable => proxy.close; throw exn }
try {
connect_session(host = fw.local_host, port = fw.local_port,
host_key_permissive = permissive,
nominal_host = host, nominal_user = user, user = user,
on_close = () => { fw.close; proxy.close })
}
catch { case exn: Throwable => fw.close; proxy.close; throw exn }
}
}
}
/* logging */
- def logging(verbose: Boolean = true, debug: Boolean = false)
+ def logging(verbose: Boolean = true, debug: Boolean = false): Unit =
{
JSch.setLogger(if (verbose) new Logger(debug) else null)
}
private class Logger(debug: Boolean) extends JSch_Logger
{
def isEnabled(level: Int): Boolean = level != JSch_Logger.DEBUG || debug
- def log(level: Int, msg: String)
+ def log(level: Int, msg: String): Unit =
{
level match {
case JSch_Logger.ERROR | JSch_Logger.FATAL => Output.error_message(msg)
case JSch_Logger.WARN => Output.warning(msg)
case _ => Output.writeln(msg)
}
}
}
/* user info */
object No_User_Info extends UserInfo
{
def getPassphrase: String = null
def getPassword: String = null
def promptPassword(msg: String): Boolean = false
def promptPassphrase(msg: String): Boolean = false
def promptYesNo(msg: String): Boolean = false
def showMessage(msg: String): Unit = Output.writeln(msg)
}
/* port forwarding */
object Port_Forwarding
{
def open(ssh: Session, ssh_close: Boolean,
local_host: String, local_port: Int, remote_host: String, remote_port: Int): Port_Forwarding =
{
val port = ssh.session.setPortForwardingL(local_host, local_port, remote_host, remote_port)
new Port_Forwarding(ssh, ssh_close, local_host, port, remote_host, remote_port)
}
}
class Port_Forwarding private[SSH](
ssh: SSH.Session,
ssh_close: Boolean,
val local_host: String,
val local_port: Int,
val remote_host: String,
val remote_port: Int) extends AutoCloseable
{
override def toString: String =
local_host + ":" + local_port + ":" + remote_host + ":" + remote_port
- def close()
+ def close(): Unit =
{
ssh.session.delPortForwardingL(local_host, local_port)
if (ssh_close) ssh.close()
}
}
/* Sftp channel */
type Attrs = SftpATTRS
sealed case class Dir_Entry(name: String, is_dir: Boolean)
{
def is_file: Boolean = !is_dir
}
/* exec channel */
private val exec_wait_delay = Time.seconds(0.3)
class Exec private[SSH](session: Session, channel: ChannelExec) extends AutoCloseable
{
override def toString: String = "exec " + session.toString
- def close() { channel.disconnect }
+ def close(): Unit = channel.disconnect
val exit_status: Future[Int] =
Future.thread("ssh_wait") {
while (!channel.isClosed) exec_wait_delay.sleep
channel.getExitStatus
}
val stdin: OutputStream = channel.getOutputStream
val stdout: InputStream = channel.getInputStream
val stderr: InputStream = channel.getErrStream
// connect after preparing streams
channel.connect(connect_timeout(session.options))
def result(
progress_stdout: String => Unit = (_: String) => (),
progress_stderr: String => Unit = (_: String) => (),
strict: Boolean = true): Process_Result =
{
stdin.close
def read_lines(stream: InputStream, progress: String => Unit): List[String] =
{
val result = new mutable.ListBuffer[String]
val line_buffer = new ByteArrayOutputStream(100)
- def line_flush()
+ def line_flush(): Unit =
{
val line = Library.trim_line(line_buffer.toString(UTF8.charset_name))
progress(line)
result += line
line_buffer.reset
}
var c = 0
var finished = false
while (!finished) {
while ({ c = stream.read; c != -1 && c != 10 }) line_buffer.write(c)
if (c == 10) line_flush()
else if (channel.isClosed) {
if (line_buffer.size > 0) line_flush()
finished = true
}
else exec_wait_delay.sleep
}
result.toList
}
val out_lines = Future.thread("ssh_stdout") { read_lines(stdout, progress_stdout) }
val err_lines = Future.thread("ssh_stderr") { read_lines(stderr, progress_stderr) }
- def terminate()
+ def terminate(): Unit =
{
close
out_lines.join
err_lines.join
exit_status.join
}
val rc =
try { exit_status.join }
catch { case Exn.Interrupt() => terminate(); Exn.Interrupt.return_code }
close
if (strict && rc == Exn.Interrupt.return_code) throw Exn.Interrupt()
Process_Result(rc, out_lines.join, err_lines.join)
}
}
/* session */
class Session private[SSH](
val options: Options,
val session: JSch_Session,
on_close: () => Unit,
val nominal_host: String,
val nominal_user: String) extends System with AutoCloseable
{
def update_options(new_options: Options): Session =
new Session(new_options, session, on_close, nominal_host, nominal_user)
def host: String = if (session.getHost == null) "" else session.getHost
override def hg_url: String =
"ssh://" + user_prefix(nominal_user) + nominal_host + "/"
override def toString: String =
user_prefix(session.getUserName) + host + port_suffix(session.getPort) +
(if (session.isConnected) "" else " (disconnected)")
/* port forwarding */
def port_forwarding(
remote_port: Int, remote_host: String = "localhost",
local_port: Int = 0, local_host: String = "localhost",
ssh_close: Boolean = false): Port_Forwarding =
Port_Forwarding.open(this, ssh_close, local_host, local_port, remote_host, remote_port)
/* sftp channel */
val sftp: ChannelSftp = session.openChannel("sftp").asInstanceOf[ChannelSftp]
sftp.connect(connect_timeout(options))
- def close() { sftp.disconnect; session.disconnect; on_close() }
+ def close(): Unit = { sftp.disconnect; session.disconnect; on_close() }
val settings: Map[String, String] =
{
val home = sftp.getHome
Map("HOME" -> home, "USER_HOME" -> home)
}
override def expand_path(path: Path): Path = path.expand_env(settings)
def remote_path(path: Path): String = expand_path(path).implode
override def bash_path(path: Path): String = Bash.string(remote_path(path))
def chmod(permissions: Int, path: Path): Unit = sftp.chmod(permissions, remote_path(path))
def mv(path1: Path, path2: Path): Unit = sftp.rename(remote_path(path1), remote_path(path2))
def rm(path: Path): Unit = sftp.rm(remote_path(path))
def mkdir(path: Path): Unit = sftp.mkdir(remote_path(path))
def rmdir(path: Path): Unit = sftp.rmdir(remote_path(path))
private def test_entry(path: Path, as_dir: Boolean): Boolean =
try {
val is_dir = sftp.stat(remote_path(path)).isDir
if (as_dir) is_dir else !is_dir
}
catch { case _: SftpException => false }
override def is_dir(path: Path): Boolean = test_entry(path, true)
override def is_file(path: Path): Boolean = test_entry(path, false)
def is_link(path: Path): Boolean =
try { sftp.lstat(remote_path(path)).isLink }
catch { case _: SftpException => false }
override def make_directory(path: Path): Path =
{
if (!is_dir(path)) {
execute(
"perl -e \"use File::Path make_path; make_path('" + remote_path(path) + "');\"")
if (!is_dir(path)) error("Failed to create directory: " + quote(remote_path(path)))
}
path
}
def read_dir(path: Path): List[Dir_Entry] =
{
if (!is_dir(path)) error("No such directory: " + path.toString)
val dir_name = remote_path(path)
val dir = sftp.ls(dir_name)
(for {
i <- (0 until dir.size).iterator
a = dir.get(i).asInstanceOf[AnyRef]
name = Untyped.get[String](a, "filename")
attrs = Untyped.get[Attrs](a, "attrs")
if name != "." && name != ".."
}
yield {
Dir_Entry(name,
if (attrs.isLink) {
try { sftp.stat(dir_name + "/" + name).isDir }
catch { case _: SftpException => false }
}
else attrs.isDir)
}).toList.sortBy(_.name)
}
def find_files(
start: Path,
pred: Path => Boolean = _ => true,
include_dirs: Boolean = false,
follow_links: Boolean = false): List[Path] =
{
val result = new mutable.ListBuffer[Path]
- def check(path: Path) { if (pred(path)) result += path }
+ def check(path: Path): Unit = { if (pred(path)) result += path }
- def find(dir: Path)
+ def find(dir: Path): Unit =
{
if (include_dirs) check(dir)
if (follow_links || !is_link(dir)) {
for (entry <- read_dir(dir)) {
val path = dir + Path.basic(entry.name)
if (entry.is_file) check(path) else find(path)
}
}
}
if (is_file(start)) check(start) else find(start)
result.toList
}
def open_input(path: Path): InputStream = sftp.get(remote_path(path))
def open_output(path: Path): OutputStream = sftp.put(remote_path(path))
def read_file(path: Path, local_path: Path): Unit =
sftp.get(remote_path(path), File.platform_path(local_path))
def read_bytes(path: Path): Bytes = using(open_input(path))(Bytes.read_stream(_))
def read(path: Path): String = using(open_input(path))(File.read_stream)
def write_file(path: Path, local_path: Path): Unit =
sftp.put(File.platform_path(local_path), remote_path(path))
def write_bytes(path: Path, bytes: Bytes): Unit =
using(open_output(path))(bytes.write_stream)
def write(path: Path, text: String): Unit =
using(open_output(path))(stream => Bytes(text).write_stream(stream))
/* exec channel */
def exec(command: String): Exec =
{
val channel = session.openChannel("exec").asInstanceOf[ChannelExec]
channel.setCommand("export USER_HOME=\"$HOME\"\n" + command)
new Exec(this, channel)
}
override def execute(command: String,
progress_stdout: String => Unit = (_: String) => (),
progress_stderr: String => Unit = (_: String) => (),
strict: Boolean = true): Process_Result =
exec(command).result(progress_stdout, progress_stderr, strict)
override def isabelle_platform: Isabelle_Platform = Isabelle_Platform(ssh = Some(this))
/* tmp dirs */
def rm_tree(dir: Path): Unit = rm_tree(remote_path(dir))
def rm_tree(remote_dir: String): Unit =
execute("rm -r -f " + Bash.string(remote_dir)).check
def tmp_dir(): String =
execute("mktemp -d -t tmp.XXXXXXXXXX").check.out
def with_tmp_dir[A](body: Path => A): A =
{
val remote_dir = tmp_dir()
try { body(Path.explode(remote_dir)) } finally { rm_tree(remote_dir) }
}
}
/* system operations */
trait System
{
def hg_url: String = ""
def expand_path(path: Path): Path = path.expand
def bash_path(path: Path): String = File.bash_path(path)
def is_dir(path: Path): Boolean = path.is_dir
def is_file(path: Path): Boolean = path.is_file
def make_directory(path: Path): Path = Isabelle_System.make_directory(path)
def execute(command: String,
progress_stdout: String => Unit = (_: String) => (),
progress_stderr: String => Unit = (_: String) => (),
strict: Boolean = true): Process_Result =
Isabelle_System.bash(command, progress_stdout = progress_stdout,
progress_stderr = progress_stderr, strict = strict)
def isabelle_platform: Isabelle_Platform = Isabelle_Platform()
}
object Local extends System
}
diff --git a/src/Pure/General/time.scala b/src/Pure/General/time.scala
--- a/src/Pure/General/time.scala
+++ b/src/Pure/General/time.scala
@@ -1,70 +1,70 @@
/* Title: Pure/General/time.scala
Author: Makarius
Time based on milliseconds.
*/
package isabelle
import java.util.Locale
import java.time.Instant
object Time
{
def seconds(s: Double): Time = new Time((s * 1000.0).round)
def minutes(s: Double): Time = new Time((s * 60000.0).round)
def ms(m: Long): Time = new Time(m)
def hms(h: Int, m: Int, s: Double): Time = seconds(s + 60 * m + 3600 * h)
def now(): Time = ms(System.currentTimeMillis())
val zero: Time = ms(0)
val start: Time = now()
def print_seconds(s: Double): String =
String.format(Locale.ROOT, "%.3f", s.asInstanceOf[AnyRef])
def instant(t: Instant): Time = ms(t.getEpochSecond * 1000L + t.getNano / 1000000L)
}
final class Time private(val ms: Long) extends AnyVal
{
def proper_ms: Option[Long] = if (ms == 0) None else Some(ms)
def seconds: Double = ms / 1000.0
def minutes: Double = ms / 60000.0
def + (t: Time): Time = new Time(ms + t.ms)
def - (t: Time): Time = new Time(ms - t.ms)
def compare(t: Time): Int = ms compare t.ms
def < (t: Time): Boolean = ms < t.ms
def <= (t: Time): Boolean = ms <= t.ms
def > (t: Time): Boolean = ms > t.ms
def >= (t: Time): Boolean = ms >= t.ms
def min(t: Time): Time = if (this < t) this else t
def max(t: Time): Time = if (this > t) this else t
def is_zero: Boolean = ms == 0
def is_relevant: Boolean = ms >= 1
override def toString: String = Time.print_seconds(seconds)
def message: String = toString + "s"
def message_hms: String =
{
val s = ms / 1000
String.format(Locale.ROOT, "%d:%02d:%02d",
java.lang.Long.valueOf(s / 3600),
java.lang.Long.valueOf((s / 60) % 60),
java.lang.Long.valueOf(s % 60))
}
def instant: Instant = Instant.ofEpochMilli(ms)
- def sleep { Thread.sleep(ms) }
+ def sleep: Unit = Thread.sleep(ms)
}
diff --git a/src/Pure/General/utf8.scala b/src/Pure/General/utf8.scala
--- a/src/Pure/General/utf8.scala
+++ b/src/Pure/General/utf8.scala
@@ -1,90 +1,90 @@
/* Title: Pure/General/utf8.scala
Author: Makarius
Variations on UTF-8.
*/
package isabelle
import java.nio.charset.Charset
import scala.io.Codec
object UTF8
{
/* charset */
val charset_name: String = "UTF-8"
val charset: Charset = Charset.forName(charset_name)
def codec(): Codec = Codec(charset)
def bytes(s: String): Array[Byte] = s.getBytes(charset)
/* permissive UTF-8 decoding */
// see also https://en.wikipedia.org/wiki/UTF-8#Description
// overlong encodings enable byte-stuffing of low-ASCII
def decode_permissive(text: CharSequence): String =
{
val buf = new java.lang.StringBuilder(text.length)
var code = -1
var rest = 0
- def flush()
+ def flush(): Unit =
{
if (code != -1) {
if (rest == 0 && Character.isValidCodePoint(code))
buf.appendCodePoint(code)
else buf.append('\uFFFD')
code = -1
rest = 0
}
}
- def init(x: Int, n: Int)
+ def init(x: Int, n: Int): Unit =
{
flush()
code = x
rest = n
}
- def push(x: Int)
+ def push(x: Int): Unit =
{
if (rest <= 0) init(x, -1)
else {
code <<= 6
code += x
rest -= 1
}
}
for (i <- 0 until text.length) {
val c = text.charAt(i)
if (c < 128) { flush(); buf.append(c) }
else if ((c & 0xC0) == 0x80) push(c & 0x3F)
else if ((c & 0xE0) == 0xC0) init(c & 0x1F, 1)
else if ((c & 0xF0) == 0xE0) init(c & 0x0F, 2)
else if ((c & 0xF8) == 0xF0) init(c & 0x07, 3)
}
flush()
buf.toString
}
private class Decode_Chars(decode: String => String,
buffer: Array[Byte], start: Int, end: Int) extends CharSequence
{
def length: Int = end - start
def charAt(i: Int): Char = (buffer(start + i).asInstanceOf[Int] & 0xFF).asInstanceOf[Char]
def subSequence(i: Int, j: Int): CharSequence =
new Decode_Chars(decode, buffer, start + i, start + j)
// toString with adhoc decoding: abuse of CharSequence interface
override def toString: String = decode(decode_permissive(this))
}
def decode_chars(decode: String => String,
buffer: Array[Byte], start: Int, end: Int): CharSequence =
{
require(0 <= start && start <= end && end <= buffer.length, "bad decode range")
new Decode_Chars(decode, buffer, start, end)
}
}
diff --git a/src/Pure/Isar/document_structure.scala b/src/Pure/Isar/document_structure.scala
--- a/src/Pure/Isar/document_structure.scala
+++ b/src/Pure/Isar/document_structure.scala
@@ -1,224 +1,224 @@
/* Title: Pure/Isar/document_structure.scala
Author: Makarius
Overall document structure.
*/
package isabelle
import scala.collection.mutable
import scala.annotation.tailrec
object Document_Structure
{
/** general structure **/
sealed abstract class Document { def length: Int }
case class Block(name: String, text: String, body: List[Document]) extends Document
{ val length: Int = (0 /: body)(_ + _.length) }
case class Atom(length: Int) extends Document
def is_theory_command(keywords: Keyword.Keywords, command: Command): Boolean =
command.span.is_kind(keywords,
kind => Keyword.theory(kind) && !Keyword.theory_end(kind), false)
def is_document_command(keywords: Keyword.Keywords, command: Command): Boolean =
command.span.is_kind(keywords, Keyword.document, false)
def is_diag_command(keywords: Keyword.Keywords, command: Command): Boolean =
command.span.is_kind(keywords, Keyword.diag, false)
def is_heading_command(command: Command): Boolean =
proper_heading_level(command).isDefined
def proper_heading_level(command: Command): Option[Int] =
command.span.name match {
case Thy_Header.CHAPTER => Some(0)
case Thy_Header.SECTION => Some(1)
case Thy_Header.SUBSECTION => Some(2)
case Thy_Header.SUBSUBSECTION => Some(3)
case Thy_Header.PARAGRAPH => Some(4)
case Thy_Header.SUBPARAGRAPH => Some(5)
case _ => None
}
def heading_level(keywords: Keyword.Keywords, command: Command): Option[Int] =
proper_heading_level(command) orElse
(if (is_theory_command(keywords, command)) Some(6) else None)
/** context blocks **/
def parse_blocks(
syntax: Outer_Syntax,
node_name: Document.Node.Name,
text: CharSequence): List[Document] =
{
def is_plain_theory(command: Command): Boolean =
is_theory_command(syntax.keywords, command) &&
!command.span.is_begin && !command.span.is_end
/* stack operations */
def buffer(): mutable.ListBuffer[Document] = new mutable.ListBuffer[Document]
var stack: List[(Command, mutable.ListBuffer[Document])] =
List((Command.empty, buffer()))
- def open(command: Command) { stack = (command, buffer()) :: stack }
+ def open(command: Command): Unit = { stack = (command, buffer()) :: stack }
def close(): Boolean =
stack match {
case (command, body) :: (_, body2) :: _ =>
body2 += Block(command.span.name, command.source, body.toList)
stack = stack.tail
true
case _ =>
false
}
- def flush() { if (is_plain_theory(stack.head._1)) close() }
+ def flush(): Unit = if (is_plain_theory(stack.head._1)) close()
def result(): List[Document] =
{
while (close()) { }
stack.head._2.toList
}
- def add(command: Command)
+ def add(command: Command): Unit =
{
if (command.span.is_begin || is_plain_theory(command)) { flush(); open(command) }
else if (command.span.is_end) { flush(); close() }
stack.head._2 += Atom(command.source.length)
}
/* result structure */
val spans = syntax.parse_spans(text)
spans.foreach(span => add(Command(Document_ID.none, node_name, Command.Blobs_Info.none, span)))
result()
}
/** section headings **/
trait Item
{
def name: String = ""
def source: String = ""
def heading_level: Option[Int] = None
}
object No_Item extends Item
class Sections(keywords: Keyword.Keywords)
{
private def buffer(): mutable.ListBuffer[Document] = new mutable.ListBuffer[Document]
private var stack: List[(Int, Item, mutable.ListBuffer[Document])] =
List((0, No_Item, buffer()))
- @tailrec private def close(level: Int => Boolean)
+ @tailrec private def close(level: Int => Boolean): Unit =
{
stack match {
case (lev, item, body) :: (_, _, body2) :: _ if level(lev) =>
body2 += Block(item.name, item.source, body.toList)
stack = stack.tail
close(level)
case _ =>
}
}
def result(): List[Document] =
{
close(_ => true)
stack.head._3.toList
}
- def add(item: Item)
+ def add(item: Item): Unit =
{
item.heading_level match {
case Some(i) =>
close(_ > i)
stack = (i + 1, item, buffer()) :: stack
case None =>
}
stack.head._3 += Atom(item.source.length)
}
}
/* outer syntax sections */
private class Command_Item(keywords: Keyword.Keywords, command: Command) extends Item
{
override def name: String = command.span.name
override def source: String = command.source
override def heading_level: Option[Int] = Document_Structure.heading_level(keywords, command)
}
def parse_sections(
syntax: Outer_Syntax,
node_name: Document.Node.Name,
text: CharSequence): List[Document] =
{
val sections = new Sections(syntax.keywords)
for { span <- syntax.parse_spans(text) } {
sections.add(
new Command_Item(syntax.keywords,
Command(Document_ID.none, node_name, Command.Blobs_Info.none, span)))
}
sections.result()
}
/* ML sections */
private class ML_Item(token: ML_Lex.Token, level: Option[Int]) extends Item
{
override def source: String = token.source
override def heading_level: Option[Int] = level
}
def parse_ml_sections(SML: Boolean, text: CharSequence): List[Document] =
{
val sections = new Sections(Keyword.Keywords.empty)
val nl = new ML_Item(ML_Lex.Token(ML_Lex.Kind.SPACE, "\n"), None)
var context: Scan.Line_Context = Scan.Finished
for (line <- Library.separated_chunks(_ == '\n', text)) {
val (toks, next_context) = ML_Lex.tokenize_line(SML, line, context)
val level =
toks.filterNot(_.is_space) match {
case List(tok) if tok.is_comment =>
val s = tok.source
if (Codepoint.iterator(s).exists(c => Character.isLetter(c) || Character.isDigit(c)))
{
if (s.startsWith("(**** ") && s.endsWith(" ****)")) Some(0)
else if (s.startsWith("(*** ") && s.endsWith(" ***)")) Some(1)
else if (s.startsWith("(** ") && s.endsWith(" **)")) Some(2)
else if (s.startsWith("(* ") && s.endsWith(" *)")) Some(3)
else None
}
else None
case _ => None
}
if (level.isDefined && context == Scan.Finished && next_context == Scan.Finished)
toks.foreach(tok => sections.add(new ML_Item(tok, if (tok.is_comment) level else None)))
else
toks.foreach(tok => sections.add(new ML_Item(tok, None)))
sections.add(nl)
context = next_context
}
sections.result()
}
}
diff --git a/src/Pure/Isar/outer_syntax.scala b/src/Pure/Isar/outer_syntax.scala
--- a/src/Pure/Isar/outer_syntax.scala
+++ b/src/Pure/Isar/outer_syntax.scala
@@ -1,210 +1,210 @@
/* Title: Pure/Isar/outer_syntax.scala
Author: Makarius
Isabelle/Isar outer syntax.
*/
package isabelle
import scala.collection.mutable
object Outer_Syntax
{
/* syntax */
val empty: Outer_Syntax = new Outer_Syntax()
def merge(syns: List[Outer_Syntax]): Outer_Syntax = (empty /: syns)(_ ++ _)
/* string literals */
def quote_string(str: String): String =
{
val result = new StringBuilder(str.length + 10)
result += '"'
for (s <- Symbol.iterator(str)) {
if (s.length == 1) {
val c = s(0)
if (c < 32 && c != YXML.X && c != YXML.Y || c == '\\' || c == '"') {
result += '\\'
if (c < 10) result += '0'
if (c < 100) result += '0'
result ++= c.asInstanceOf[Int].toString
}
else result += c
}
else result ++= s
}
result += '"'
result.toString
}
}
final class Outer_Syntax private(
val keywords: Keyword.Keywords = Keyword.Keywords.empty,
val rev_abbrevs: Thy_Header.Abbrevs = Nil,
val language_context: Completion.Language_Context = Completion.Language_Context.outer,
val has_tokens: Boolean = true)
{
/** syntax content **/
override def toString: String = keywords.toString
/* keywords */
def + (name: String, kind: String = "", load_command: String = ""): Outer_Syntax =
new Outer_Syntax(
keywords + (name, kind, load_command), rev_abbrevs, language_context, has_tokens = true)
def add_keywords(keywords: Thy_Header.Keywords): Outer_Syntax =
(this /: keywords) {
case (syntax, (name, spec)) =>
syntax +
(Symbol.decode(name), spec.kind, spec.load_command) +
(Symbol.encode(name), spec.kind, spec.load_command)
}
/* abbrevs */
def abbrevs: Thy_Header.Abbrevs = rev_abbrevs.reverse
def add_abbrevs(new_abbrevs: Thy_Header.Abbrevs): Outer_Syntax =
if (new_abbrevs.isEmpty) this
else {
val rev_abbrevs1 = Library.distinct(new_abbrevs) reverse_::: rev_abbrevs
new Outer_Syntax(keywords, rev_abbrevs1, language_context, has_tokens)
}
/* completion */
private lazy val completion: Completion =
{
val completion_keywords = (keywords.minor.iterator ++ keywords.major.iterator).toList
val completion_abbrevs =
completion_keywords.flatMap(name =>
(if (Keyword.theory_block.contains(keywords.kinds(name)))
List((name, name + "\nbegin\n\u0007\nend"))
else Nil) :::
(if (Completion.Word_Parsers.is_word(name)) List((name, name)) else Nil)) :::
abbrevs.flatMap(
{ case (a, b) =>
val a1 = Symbol.decode(a)
val a2 = Symbol.encode(a)
val b1 = Symbol.decode(b)
List((a1, b1), (a2, b1))
})
Completion.make(completion_keywords, completion_abbrevs)
}
def complete(
history: Completion.History,
unicode: Boolean,
explicit: Boolean,
start: Text.Offset,
text: CharSequence,
caret: Int,
context: Completion.Language_Context): Option[Completion.Result] =
{
completion.complete(history, unicode, explicit, start, text, caret, context)
}
/* build */
def + (header: Document.Node.Header): Outer_Syntax =
add_keywords(header.keywords).add_abbrevs(header.abbrevs)
def ++ (other: Outer_Syntax): Outer_Syntax =
if (this eq other) this
else if (this eq Outer_Syntax.empty) other
else {
val keywords1 = keywords ++ other.keywords
val rev_abbrevs1 = Library.merge(rev_abbrevs, other.rev_abbrevs)
if ((keywords eq keywords1) && (rev_abbrevs eq rev_abbrevs1)) this
else new Outer_Syntax(keywords1, rev_abbrevs1, language_context, has_tokens)
}
/* load commands */
def load_command(name: String): Option[String] =
keywords.load_commands.get(name)
def has_load_commands(text: String): Boolean =
keywords.load_commands.exists({ case (cmd, _) => text.containsSlice(cmd) })
/* language context */
def set_language_context(context: Completion.Language_Context): Outer_Syntax =
new Outer_Syntax(keywords, rev_abbrevs, context, has_tokens)
def no_tokens: Outer_Syntax =
{
require(keywords.is_empty, "bad syntax keywords")
new Outer_Syntax(
rev_abbrevs = rev_abbrevs,
language_context = language_context,
has_tokens = false)
}
/** parsing **/
/* command spans */
def parse_spans(toks: List[Token]): List[Command_Span.Span] =
{
val result = new mutable.ListBuffer[Command_Span.Span]
val content = new mutable.ListBuffer[Token]
val ignored = new mutable.ListBuffer[Token]
- def ship(content: List[Token])
+ def ship(content: List[Token]): Unit =
{
val kind =
if (content.forall(_.is_ignored)) Command_Span.Ignored_Span
else if (content.exists(_.is_error)) Command_Span.Malformed_Span
else
content.find(_.is_command) match {
case None => Command_Span.Malformed_Span
case Some(cmd) =>
val name = cmd.source
val offset =
(0 /: content.takeWhile(_ != cmd)) {
case (i, tok) => i + Symbol.length(tok.source) }
val end_offset = offset + Symbol.length(name)
val range = Text.Range(offset, end_offset) + 1
Command_Span.Command_Span(name, Position.Range(range))
}
result += Command_Span.Span(kind, content)
}
- def flush()
+ def flush(): Unit =
{
if (content.nonEmpty) { ship(content.toList); content.clear }
if (ignored.nonEmpty) { ship(ignored.toList); ignored.clear }
}
for (tok <- toks) {
if (tok.is_ignored) ignored += tok
else if (keywords.is_before_command(tok) ||
tok.is_command &&
(!content.exists(keywords.is_before_command) || content.exists(_.is_command)))
{ flush(); content += tok }
else { content ++= ignored; ignored.clear; content += tok }
}
flush()
result.toList
}
def parse_spans(input: CharSequence): List[Command_Span.Span] =
parse_spans(Token.explode(keywords, input))
}
diff --git a/src/Pure/ML/ml_console.scala b/src/Pure/ML/ml_console.scala
--- a/src/Pure/ML/ml_console.scala
+++ b/src/Pure/ML/ml_console.scala
@@ -1,84 +1,84 @@
/* Title: Pure/ML/ml_console.scala
Author: Makarius
The raw ML process in interactive mode.
*/
package isabelle
object ML_Console
{
/* command line entry point */
- def main(args: Array[String])
+ def main(args: Array[String]): Unit =
{
Command_Line.tool {
var dirs: List[Path] = Nil
var include_sessions: List[String] = Nil
var logic = Isabelle_System.getenv("ISABELLE_LOGIC")
var modes: List[String] = Nil
var no_build = false
var options = Options.init()
var raw_ml_system = false
val getopts = Getopts("""
Usage: isabelle console [OPTIONS]
Options are:
-d DIR include session directory
-i NAME include session in name-space of theories
-l NAME logic session name (default ISABELLE_LOGIC=""" + quote(logic) + """)
-m MODE add print mode for output
-n no build of session image on startup
-o OPTION override Isabelle system OPTION (via NAME=VAL or NAME)
-r bootstrap from raw Poly/ML
Build a logic session image and run the raw Isabelle ML process
in interactive mode, with line editor ISABELLE_LINE_EDITOR=""" +
quote(Isabelle_System.getenv("ISABELLE_LINE_EDITOR")) + """.
""",
"d:" -> (arg => dirs = dirs ::: List(Path.explode(arg))),
"i:" -> (arg => include_sessions = include_sessions ::: List(arg)),
"l:" -> (arg => logic = arg),
"m:" -> (arg => modes = arg :: modes),
"n" -> (_ => no_build = true),
"o:" -> (arg => options = options + arg),
"r" -> (_ => raw_ml_system = true))
val more_args = getopts(args)
if (more_args.nonEmpty) getopts.usage()
val sessions_structure = Sessions.load_structure(options, dirs = dirs)
val store = Sessions.store(options)
// build logic
if (!no_build && !raw_ml_system) {
val progress = new Console_Progress()
val rc =
progress.interrupt_handler {
Build.build_logic(options, logic, build_heap = true, progress = progress, dirs = dirs)
}
if (rc != 0) sys.exit(rc)
}
// process loop
val process =
ML_Process(options, sessions_structure, store,
logic = logic, args = List("-i"), redirect = true,
modes = if (raw_ml_system) Nil else modes ::: List("ASCII"),
raw_ml_system = raw_ml_system,
session_base =
if (raw_ml_system) None
else Some(Sessions.base_info(
options, logic, dirs = dirs, include_sessions = include_sessions).check.base))
POSIX_Interrupt.handler { process.interrupt } {
new TTY_Loop(process.stdin, process.stdout).join
val rc = process.join
if (rc != 0) sys.exit(rc)
}
}
}
}
diff --git a/src/Pure/ML/ml_statistics.scala b/src/Pure/ML/ml_statistics.scala
--- a/src/Pure/ML/ml_statistics.scala
+++ b/src/Pure/ML/ml_statistics.scala
@@ -1,324 +1,324 @@
/* Title: Pure/ML/ml_statistics.scala
Author: Makarius
ML runtime statistics.
*/
package isabelle
import scala.annotation.tailrec
import scala.collection.mutable
import scala.collection.immutable.{SortedSet, SortedMap}
import scala.swing.{Frame, Component}
import org.jfree.data.xy.{XYSeries, XYSeriesCollection}
import org.jfree.chart.{JFreeChart, ChartPanel, ChartFactory}
import org.jfree.chart.plot.PlotOrientation
object ML_Statistics
{
/* properties */
val Now = new Properties.Double("now")
def now(props: Properties.T): Double = Now.unapply(props).get
/* memory status */
val Heap_Size = new Properties.Long("size_heap")
val Heap_Free = new Properties.Long("size_heap_free_last_GC")
val GC_Percent = new Properties.Int("GC_percent")
sealed case class Memory_Status(heap_size: Long, heap_free: Long, gc_percent: Int)
{
def heap_used: Long = (heap_size - heap_free) max 0
def heap_used_fraction: Double =
if (heap_size == 0) 0.0 else heap_used.toDouble / heap_size
def gc_progress: Option[Double] =
if (1 <= gc_percent && gc_percent <= 100) Some((gc_percent - 1) * 0.01) else None
}
def memory_status(props: Properties.T): Memory_Status =
{
val heap_size = Heap_Size.get(props)
val heap_free = Heap_Free.get(props)
val gc_percent = GC_Percent.get(props)
Memory_Status(heap_size, heap_free, gc_percent)
}
/* monitor process */
def monitor(pid: Long,
stats_dir: String = "",
delay: Time = Time.seconds(0.5),
- consume: Properties.T => Unit = Console.println)
+ consume: Properties.T => Unit = Console.println): Unit =
{
- def progress_stdout(line: String)
+ def progress_stdout(line: String): Unit =
{
val props =
Library.space_explode(',', line).flatMap((entry: String) =>
Library.space_explode('=', entry) match {
case List(a, b) => Some((a, b))
case _ => None
})
if (props.nonEmpty) consume(props)
}
val env_prefix =
if (stats_dir.isEmpty) "" else "export POLYSTATSDIR=" + Bash.string(stats_dir) + "\n"
Bash.process(env_prefix + "exec \"$POLYML_EXE\" -q --use src/Pure/ML/ml_statistics.ML --eval " +
Bash.string("ML_Statistics.monitor " + ML_Syntax.print_long(pid) + " " +
ML_Syntax.print_double(delay.seconds)),
cwd = Path.explode("~~").file)
.result(progress_stdout = progress_stdout, strict = false).check
}
/* protocol handler */
class Handler extends Session.Protocol_Handler
{
private var session: Session = null
private var monitoring: Future[Unit] = Future.value(())
override def init(session: Session): Unit = synchronized
{
this.session = session
}
override def exit(): Unit = synchronized
{
session = null
monitoring.cancel
}
private def consume(props: Properties.T): Unit = synchronized
{
if (session != null) {
val props1 = (session.cache.props(props ::: Java_Statistics.jvm_statistics()))
session.runtime_statistics.post(Session.Runtime_Statistics(props1))
}
}
private def ml_statistics(msg: Prover.Protocol_Output): Boolean = synchronized
{
msg.properties match {
case Markup.ML_Statistics(pid, stats_dir) =>
monitoring =
Future.thread("ML_statistics") {
monitor(pid, stats_dir = stats_dir, consume = consume)
}
true
case _ => false
}
}
override val functions = List(Markup.ML_Statistics.name -> ml_statistics)
}
/* memory fields (mega bytes) */
def mem_print(x: Long): Option[String] =
if (x == 0L) None else Some(x.toString + " M")
def mem_scale(x: Long): Long = x / 1024 / 1024
def mem_field_scale(name: String, x: Double): Double =
if (heap_fields._2.contains(name) || program_fields._2.contains(name))
mem_scale(x.toLong).toDouble
else x
val CODE_SIZE = "size_code"
val STACK_SIZE = "size_stacks"
val HEAP_SIZE = "size_heap"
/* standard fields */
type Fields = (String, List[String])
val tasks_fields: Fields =
("Future tasks",
List("tasks_ready", "tasks_pending", "tasks_running", "tasks_passive",
"tasks_urgent", "tasks_total"))
val workers_fields: Fields =
("Worker threads", List("workers_total", "workers_active", "workers_waiting"))
val GC_fields: Fields =
("GCs", List("partial_GCs", "full_GCs", "share_passes"))
val heap_fields: Fields =
("Heap", List(HEAP_SIZE, "size_allocation", "size_allocation_free",
"size_heap_free_last_full_GC", "size_heap_free_last_GC"))
val program_fields: Fields =
("Program", List("size_code", "size_stacks"))
val threads_fields: Fields =
("Threads", List("threads_total", "threads_in_ML", "threads_wait_condvar",
"threads_wait_IO", "threads_wait_mutex", "threads_wait_signal"))
val time_fields: Fields =
("Time", List("time_elapsed", "time_elapsed_GC", "time_CPU", "time_GC"))
val speed_fields: Fields =
("Speed", List("speed_CPU", "speed_GC"))
private val time_speed = Map("time_CPU" -> "speed_CPU", "time_GC" -> "speed_GC")
val java_heap_fields: Fields =
("Java heap", List("java_heap_size", "java_heap_used"))
val java_thread_fields: Fields =
("Java threads", List("java_threads_total", "java_workers_total", "java_workers_active"))
val main_fields: List[Fields] =
List(heap_fields, tasks_fields, workers_fields)
val other_fields: List[Fields] =
List(threads_fields, GC_fields, program_fields, time_fields, speed_fields,
java_heap_fields, java_thread_fields)
val all_fields: List[Fields] = main_fields ::: other_fields
/* content interpretation */
final case class Entry(time: Double, data: Map[String, Double])
{
def get(field: String): Double = data.getOrElse(field, 0.0)
}
val empty: ML_Statistics = apply(Nil)
def apply(ml_statistics0: List[Properties.T], heading: String = "",
domain: String => Boolean = (key: String) => true): ML_Statistics =
{
require(ml_statistics0.forall(props => Now.unapply(props).isDefined), "missing \"now\" field")
val ml_statistics = ml_statistics0.sortBy(now)
val time_start = if (ml_statistics.isEmpty) 0.0 else now(ml_statistics.head)
val duration = if (ml_statistics.isEmpty) 0.0 else now(ml_statistics.last) - time_start
val fields =
SortedSet.empty[String] ++
(for {
props <- ml_statistics.iterator
(x, _) <- props.iterator
if x != Now.name && domain(x) } yield x)
val content =
{
var last_edge = Map.empty[String, (Double, Double, Double)]
val result = new mutable.ListBuffer[ML_Statistics.Entry]
for (props <- ml_statistics) {
val time = now(props) - time_start
// rising edges -- relative speed
val speeds =
(for {
(key, value) <- props.iterator
key1 <- time_speed.get(key)
if domain(key1)
} yield {
val (x0, y0, s0) = last_edge.getOrElse(key, (0.0, 0.0, 0.0))
val x1 = time
val y1 = java.lang.Double.parseDouble(value)
val s1 = if (x1 == x0) 0.0 else (y1 - y0) / (x1 - x0)
if (y1 > y0) {
last_edge += (key -> (x1, y1, s1))
(key1, s1.toString)
}
else (key1, s0.toString)
}).toList
val data =
SortedMap.empty[String, Double] ++
(for {
(x, y) <- props.iterator ++ speeds.iterator
if x != Now.name && domain(x)
z = java.lang.Double.parseDouble(y) if z != 0.0
} yield { (x.intern, mem_field_scale(x, z)) })
result += ML_Statistics.Entry(time, data)
}
result.toList
}
new ML_Statistics(heading, fields, content, time_start, duration)
}
}
final class ML_Statistics private(
val heading: String,
val fields: Set[String],
val content: List[ML_Statistics.Entry],
val time_start: Double,
val duration: Double)
{
/* content */
def maximum(field: String): Double =
(0.0 /: content)({ case (m, e) => m max e.get(field) })
def average(field: String): Double =
{
@tailrec def sum(t0: Double, list: List[ML_Statistics.Entry], acc: Double): Double =
list match {
case Nil => acc
case e :: es =>
val t = e.time
sum(t, es, (t - t0) * e.get(field) + acc)
}
content match {
case Nil => 0.0
case List(e) => e.get(field)
case e :: es => sum(e.time, es, 0.0) / duration
}
}
/* charts */
- def update_data(data: XYSeriesCollection, selected_fields: List[String])
+ def update_data(data: XYSeriesCollection, selected_fields: List[String]): Unit =
{
data.removeAllSeries
for (field <- selected_fields) {
val series = new XYSeries(field)
content.foreach(entry => series.add(entry.time, entry.get(field)))
data.addSeries(series)
}
}
def chart(title: String, selected_fields: List[String]): JFreeChart =
{
val data = new XYSeriesCollection
update_data(data, selected_fields)
ChartFactory.createXYLineChart(title, "time", "value", data,
PlotOrientation.VERTICAL, true, true, true)
}
def chart(fields: ML_Statistics.Fields): JFreeChart =
chart(fields._1, fields._2)
def show_frames(fields: List[ML_Statistics.Fields] = ML_Statistics.main_fields): Unit =
fields.map(chart).foreach(c =>
GUI_Thread.later {
new Frame {
iconImage = GUI.isabelle_image()
title = heading
contents = Component.wrap(new ChartPanel(c))
visible = true
}
})
}
diff --git a/src/Pure/PIDE/byte_message.scala b/src/Pure/PIDE/byte_message.scala
--- a/src/Pure/PIDE/byte_message.scala
+++ b/src/Pure/PIDE/byte_message.scala
@@ -1,116 +1,116 @@
/* Title: Pure/General/byte_message.scala
Author: Makarius
Byte-oriented messages.
*/
package isabelle
import java.io.{ByteArrayOutputStream, OutputStream, InputStream, IOException}
object Byte_Message
{
/* output operations */
def write(stream: OutputStream, bytes: List[Bytes]): Unit =
bytes.foreach(_.write_stream(stream))
def flush(stream: OutputStream): Unit =
try { stream.flush() }
catch { case _: IOException => }
def write_line(stream: OutputStream, bytes: Bytes): Unit =
{
write(stream, List(bytes, Bytes.newline))
flush(stream)
}
/* input operations */
def read(stream: InputStream, n: Int): Bytes =
Bytes.read_stream(stream, limit = n)
def read_block(stream: InputStream, n: Int): (Option[Bytes], Int) =
{
val msg = read(stream, n)
val len = msg.length
(if (len == n) Some(msg) else None, len)
}
def read_line(stream: InputStream): Option[Bytes] =
{
val line = new ByteArrayOutputStream(100)
var c = 0
while ({ c = stream.read; c != -1 && c != 10 }) line.write(c)
if (c == -1 && line.size == 0) None
else {
val a = line.toByteArray
val n = a.length
val len = if (n > 0 && a(n - 1) == 13) n - 1 else n
Some(Bytes(a, 0, len))
}
}
/* messages with multiple chunks (arbitrary content) */
private def make_header(ns: List[Int]): List[Bytes] =
List(Bytes(ns.mkString(",")), Bytes.newline)
- def write_message(stream: OutputStream, chunks: List[Bytes])
+ def write_message(stream: OutputStream, chunks: List[Bytes]): Unit =
{
write(stream, make_header(chunks.map(_.length)) ::: chunks)
flush(stream)
}
private def parse_header(line: String): List[Int] =
try { space_explode(',', line).map(Value.Nat.parse) }
catch { case ERROR(_) => error("Malformed message header: " + quote(line)) }
private def read_chunk(stream: InputStream, n: Int): Bytes =
read_block(stream, n) match {
case (Some(chunk), _) => chunk
case (None, len) =>
error("Malformed message chunk: unexpected EOF after " + len + " of " + n + " bytes")
}
def read_message(stream: InputStream): Option[List[Bytes]] =
read_line(stream).map(line => parse_header(line.text).map(read_chunk(stream, _)))
/* hybrid messages: line or length+block (restricted content) */
private def is_length(msg: Bytes): Boolean =
!msg.is_empty && msg.iterator.forall(b => Symbol.is_ascii_digit(b.toChar))
private def is_terminated(msg: Bytes): Boolean =
{
val len = msg.length
len > 0 && Symbol.is_ascii_line_terminator(msg.charAt(len - 1))
}
- def write_line_message(stream: OutputStream, msg: Bytes)
+ def write_line_message(stream: OutputStream, msg: Bytes): Unit =
{
if (is_length(msg) || is_terminated(msg))
error ("Bad content for line message:\n" ++ msg.text.take(100))
val n = msg.length
write(stream,
(if (n > 100 || msg.iterator.contains(10)) make_header(List(n + 1)) else Nil) :::
List(msg, Bytes.newline))
flush(stream)
}
def read_line_message(stream: InputStream): Option[Bytes] =
read_line(stream) match {
case None => None
case Some(line) =>
Value.Nat.unapply(line.text) match {
case None => Some(line)
case Some(n) => read_block(stream, n)._1.map(_.trim_line)
}
}
}
diff --git a/src/Pure/PIDE/document.scala b/src/Pure/PIDE/document.scala
--- a/src/Pure/PIDE/document.scala
+++ b/src/Pure/PIDE/document.scala
@@ -1,1264 +1,1264 @@
/* Title: Pure/PIDE/document.scala
Author: Makarius
Document as collection of named nodes, each consisting of an editable
list of commands, associated with asynchronous execution process.
*/
package isabelle
import scala.collection.mutable
object Document
{
/** document structure **/
/* overlays -- print functions with arguments */
object Overlays
{
val empty = new Overlays(Map.empty)
}
final class Overlays private(rep: Map[Node.Name, Node.Overlays])
{
def apply(name: Node.Name): Node.Overlays =
rep.getOrElse(name, Node.Overlays.empty)
private def update(name: Node.Name, f: Node.Overlays => Node.Overlays): Overlays =
{
val node_overlays = f(apply(name))
new Overlays(if (node_overlays.is_empty) rep - name else rep + (name -> node_overlays))
}
def insert(command: Command, fn: String, args: List[String]): Overlays =
update(command.node_name, _.insert(command, fn, args))
def remove(command: Command, fn: String, args: List[String]): Overlays =
update(command.node_name, _.remove(command, fn, args))
override def toString: String = rep.mkString("Overlays(", ",", ")")
}
/* document blobs: auxiliary files */
sealed case class Blob(bytes: Bytes, source: String, chunk: Symbol.Text_Chunk, changed: Boolean)
{
def unchanged: Blob = copy(changed = false)
}
object Blobs
{
def apply(blobs: Map[Node.Name, Blob]): Blobs = new Blobs(blobs)
val empty: Blobs = apply(Map.empty)
}
final class Blobs private(blobs: Map[Node.Name, Blob])
{
def get(name: Node.Name): Option[Blob] = blobs.get(name)
def changed(name: Node.Name): Boolean =
get(name) match {
case Some(blob) => blob.changed
case None => false
}
override def toString: String = blobs.mkString("Blobs(", ",", ")")
}
/* document nodes: theories and auxiliary files */
type Edit[A, B] = (Node.Name, Node.Edit[A, B])
type Edit_Text = Edit[Text.Edit, Text.Perspective]
type Edit_Command = Edit[Command.Edit, Command.Perspective]
object Node
{
/* header and name */
sealed case class Header(
imports_pos: List[(Name, Position.T)] = Nil,
keywords: Thy_Header.Keywords = Nil,
abbrevs: Thy_Header.Abbrevs = Nil,
errors: List[String] = Nil)
{
def imports_offset: Map[Int, Name] =
(for { (name, Position.Offset(i)) <- imports_pos } yield i -> name).toMap
def imports: List[Name] = imports_pos.map(_._1)
def append_errors(msgs: List[String]): Header =
copy(errors = errors ::: msgs)
def cat_errors(msg2: String): Header =
copy(errors = errors.map(msg1 => Exn.cat_message(msg1, msg2)))
}
val no_header: Header = Header()
def bad_header(msg: String): Header = Header(errors = List(msg))
object Name
{
val empty: Name = Name("")
object Ordering extends scala.math.Ordering[Name]
{
def compare(name1: Name, name2: Name): Int = name1.node compare name2.node
}
type Graph[A] = isabelle.Graph[Node.Name, A]
def make_graph[A](entries: List[((Name, A), List[Name])]): Graph[A] =
Graph.make(entries, symmetric = true)(Ordering)
}
sealed case class Name(node: String, master_dir: String = "", theory: String = "")
{
override def hashCode: Int = node.hashCode
override def equals(that: Any): Boolean =
that match {
case other: Name => node == other.node
case _ => false
}
def path: Path = Path.explode(File.standard_path(node))
def master_dir_path: Path = Path.explode(File.standard_path(master_dir))
def expand: Name =
Name(path.expand.implode, master_dir_path.expand.implode, theory)
def symbolic: Name =
Name(path.implode_symbolic, master_dir_path.implode_symbolic, theory)
def is_theory: Boolean = theory.nonEmpty
def theory_base_name: String = Long_Name.base_name(theory)
override def toString: String = if (is_theory) theory else node
def map(f: String => String): Name = copy(f(node), f(master_dir), theory)
def map_theory(f: String => String): Name = copy(node, master_dir, f(theory))
def json: JSON.Object.T =
JSON.Object("node_name" -> node, "theory_name" -> theory)
}
sealed case class Entry(name: Node.Name, header: Node.Header)
{
def map(f: String => String): Entry = copy(name = name.map(f))
override def toString: String = name.toString
}
/* node overlays */
object Overlays
{
val empty = new Overlays(Multi_Map.empty)
}
final class Overlays private(rep: Multi_Map[Command, (String, List[String])])
{
def commands: Set[Command] = rep.keySet
def is_empty: Boolean = rep.isEmpty
def dest: List[(Command, (String, List[String]))] = rep.iterator.toList
def insert(cmd: Command, fn: String, args: List[String]): Overlays =
new Overlays(rep.insert(cmd, (fn, args)))
def remove(cmd: Command, fn: String, args: List[String]): Overlays =
new Overlays(rep.remove(cmd, (fn, args)))
override def toString: String = rep.mkString("Node.Overlays(", ",", ")")
}
/* edits */
sealed abstract class Edit[A, B]
{
- def foreach(f: A => Unit)
+ def foreach(f: A => Unit): Unit =
{
this match {
case Edits(es) => es.foreach(f)
case _ =>
}
}
def is_void: Boolean =
this match {
case Edits(Nil) => true
case _ => false
}
}
case class Blob[A, B](blob: Document.Blob) extends Edit[A, B]
case class Edits[A, B](edits: List[A]) extends Edit[A, B]
case class Deps[A, B](header: Header) extends Edit[A, B]
case class Perspective[A, B](required: Boolean, visible: B, overlays: Overlays) extends Edit[A, B]
/* perspective */
type Perspective_Text = Perspective[Text.Edit, Text.Perspective]
type Perspective_Command = Perspective[Command.Edit, Command.Perspective]
val no_perspective_text: Perspective_Text =
Perspective(false, Text.Perspective.empty, Overlays.empty)
val no_perspective_command: Perspective_Command =
Perspective(false, Command.Perspective.empty, Overlays.empty)
def is_no_perspective_text(perspective: Perspective_Text): Boolean =
!perspective.required &&
perspective.visible.is_empty &&
perspective.overlays.is_empty
def is_no_perspective_command(perspective: Perspective_Command): Boolean =
!perspective.required &&
perspective.visible.is_empty &&
perspective.overlays.is_empty
/* commands */
object Commands
{
def apply(commands: Linear_Set[Command]): Commands = new Commands(commands)
val empty: Commands = apply(Linear_Set.empty)
def starts(commands: Iterator[Command], offset: Text.Offset = 0)
: Iterator[(Command, Text.Offset)] =
{
var i = offset
for (command <- commands) yield {
val start = i
i += command.length
(command, start)
}
}
def starts_pos(commands: Iterator[Command], pos: Token.Pos = Token.Pos.start)
: Iterator[(Command, Token.Pos)] =
{
var p = pos
for (command <- commands) yield {
val start = p
p = (p /: command.span.content)(_.advance(_))
(command, start)
}
}
private val block_size = 256
}
final class Commands private(val commands: Linear_Set[Command])
{
lazy val load_commands: List[Command] =
commands.iterator.filter(cmd => cmd.blobs.nonEmpty).toList
private lazy val full_index: (Array[(Command, Text.Offset)], Text.Range) =
{
val blocks = new mutable.ListBuffer[(Command, Text.Offset)]
var next_block = 0
var last_stop = 0
for ((command, start) <- Commands.starts(commands.iterator)) {
last_stop = start + command.length
while (last_stop + 1 > next_block) {
blocks += (command -> start)
next_block += Commands.block_size
}
}
(blocks.toArray, Text.Range(0, last_stop))
}
private def full_range: Text.Range = full_index._2
def iterator(i: Text.Offset = 0): Iterator[(Command, Text.Offset)] =
{
if (commands.nonEmpty && full_range.contains(i)) {
val (cmd0, start0) = full_index._1(i / Commands.block_size)
Node.Commands.starts(commands.iterator(cmd0), start0) dropWhile {
case (cmd, start) => start + cmd.length <= i }
}
else Iterator.empty
}
}
val empty: Node = new Node()
}
final class Node private(
val get_blob: Option[Document.Blob] = None,
val header: Node.Header = Node.no_header,
val syntax: Option[Outer_Syntax] = None,
val text_perspective: Text.Perspective = Text.Perspective.empty,
val perspective: Node.Perspective_Command = Node.no_perspective_command,
_commands: Node.Commands = Node.Commands.empty)
{
def is_empty: Boolean =
get_blob.isEmpty &&
header == Node.no_header &&
text_perspective.is_empty &&
Node.is_no_perspective_command(perspective) &&
commands.isEmpty
def has_header: Boolean = header != Node.no_header
override def toString: String =
if (is_empty) "empty"
else if (get_blob.isDefined) "blob"
else "node"
def commands: Linear_Set[Command] = _commands.commands
def load_commands: List[Command] = _commands.load_commands
def load_commands_changed(doc_blobs: Blobs): Boolean =
load_commands.exists(_.blobs_changed(doc_blobs))
def init_blob(blob: Blob): Node = new Node(get_blob = Some(blob.unchanged))
def update_header(new_header: Node.Header): Node =
new Node(get_blob, new_header, syntax, text_perspective, perspective, _commands)
def update_syntax(new_syntax: Option[Outer_Syntax]): Node =
new Node(get_blob, header, new_syntax, text_perspective, perspective, _commands)
def update_perspective(
new_text_perspective: Text.Perspective,
new_perspective: Node.Perspective_Command): Node =
new Node(get_blob, header, syntax, new_text_perspective, new_perspective, _commands)
def edit_perspective: Node.Edit[Text.Edit, Text.Perspective] =
Node.Perspective(perspective.required, text_perspective, perspective.overlays)
def same_perspective(
other_text_perspective: Text.Perspective,
other_perspective: Node.Perspective_Command): Boolean =
text_perspective == other_text_perspective &&
perspective.required == other_perspective.required &&
perspective.visible.same(other_perspective.visible) &&
perspective.overlays == other_perspective.overlays
def update_commands(new_commands: Linear_Set[Command]): Node =
if (new_commands eq _commands.commands) this
else
new Node(get_blob, header, syntax, text_perspective, perspective,
Node.Commands(new_commands))
def command_iterator(i: Text.Offset = 0): Iterator[(Command, Text.Offset)] =
_commands.iterator(i)
def command_iterator(range: Text.Range): Iterator[(Command, Text.Offset)] =
command_iterator(range.start) takeWhile { case (_, start) => start < range.stop }
def command_start(cmd: Command): Option[Text.Offset] =
Node.Commands.starts(commands.iterator).find(_._1 == cmd).map(_._2)
def source: String =
get_blob match {
case Some(blob) => blob.source
case None => command_iterator(0).map({ case (cmd, _) => cmd.source }).mkString
}
}
/* development graph */
object Nodes
{
val empty: Nodes = new Nodes(Graph.empty(Node.Name.Ordering))
}
final class Nodes private(graph: Graph[Node.Name, Node])
{
def apply(name: Node.Name): Node =
graph.default_node(name, Node.empty).get_node(name)
def is_suppressed(name: Node.Name): Boolean =
{
val graph1 = graph.default_node(name, Node.empty)
graph1.is_maximal(name) && graph1.get_node(name).is_empty
}
def purge_suppressed: Option[Nodes] =
graph.keys_iterator.filter(is_suppressed).toList match {
case Nil => None
case del => Some(new Nodes((graph /: del)(_.del_node(_))))
}
def + (entry: (Node.Name, Node)): Nodes =
{
val (name, node) = entry
val imports = node.header.imports
val graph1 =
(graph.default_node(name, Node.empty) /: imports)((g, p) => g.default_node(p, Node.empty))
val graph2 = (graph1 /: graph1.imm_preds(name))((g, dep) => g.del_edge(dep, name))
val graph3 = (graph2 /: imports)((g, dep) => g.add_edge(dep, name))
new Nodes(graph3.map_node(name, _ => node))
}
def domain: Set[Node.Name] = graph.domain
def iterator: Iterator[(Node.Name, Node)] =
graph.iterator.map({ case (name, (node, _)) => (name, node) })
def theory_name(theory: String): Option[Node.Name] =
graph.keys_iterator.find(name => name.theory == theory)
def commands_loading(file_name: Node.Name): List[Command] =
(for {
(_, node) <- iterator
cmd <- node.load_commands.iterator
name <- cmd.blobs_names.iterator
if name == file_name
} yield cmd).toList
def descendants(names: List[Node.Name]): List[Node.Name] = graph.all_succs(names)
def requirements(names: List[Node.Name]): List[Node.Name] = graph.all_preds_rev(names)
def topological_order: List[Node.Name] = graph.topological_order
override def toString: String = topological_order.mkString("Nodes(", ",", ")")
}
/** versioning **/
/* particular document versions */
object Version
{
val init: Version = new Version()
def make(nodes: Nodes): Version = new Version(Document_ID.make(), nodes)
def purge_future(versions: Map[Document_ID.Version, Version], future: Future[Version])
: Future[Version] =
{
if (future.is_finished) {
val version = future.join
versions.get(version.id) match {
case Some(version1) if !(version eq version1) => Future.value(version1)
case _ => future
}
}
else future
}
def purge_suppressed(
versions: Map[Document_ID.Version, Version]): Map[Document_ID.Version, Version] =
{
(versions /:
(for ((id, v) <- versions.iterator; v1 <- v.purge_suppressed) yield (id, v1)))(_ + _)
}
}
final class Version private(
val id: Document_ID.Version = Document_ID.none,
val nodes: Nodes = Nodes.empty)
{
override def toString: String = "Version(" + id + ")"
def purge_suppressed: Option[Version] =
nodes.purge_suppressed.map(new Version(id, _))
}
/* changes of plain text, eventually resulting in document edits */
object Change
{
val init: Change = new Change()
def make(previous: Future[Version], edits: List[Edit_Text], version: Future[Version]): Change =
new Change(Some(previous), edits.reverse, version)
}
final class Change private(
val previous: Option[Future[Version]] = Some(Future.value(Version.init)),
val rev_edits: List[Edit_Text] = Nil,
val version: Future[Version] = Future.value(Version.init))
{
def is_finished: Boolean =
(previous match { case None => true case Some(future) => future.is_finished }) &&
version.is_finished
def truncate: Change = new Change(None, Nil, version)
def purge(versions: Map[Document_ID.Version, Version]): Option[Change] =
{
val previous1 = previous.map(Version.purge_future(versions, _))
val version1 = Version.purge_future(versions, version)
if ((previous eq previous1) && (version eq version1)) None
else Some(new Change(previous1, rev_edits, version1))
}
}
/* history navigation */
object History
{
val init: History = new History()
}
final class History private(
val undo_list: List[Change] = List(Change.init)) // non-empty list
{
override def toString: String = "History(" + undo_list.length + ")"
def tip: Change = undo_list.head
def + (change: Change): History = new History(change :: undo_list)
def prune(check: Change => Boolean, retain: Int): Option[(List[Change], History)] =
{
val n = undo_list.iterator.zipWithIndex.find(p => check(p._1)).get._2 + 1
val (retained, dropped) = undo_list.splitAt(n max retain)
retained.splitAt(retained.length - 1) match {
case (prefix, List(last)) => Some(dropped, new History(prefix ::: List(last.truncate)))
case _ => None
}
}
def purge(versions: Map[Document_ID.Version, Version]): History =
{
val undo_list1 = undo_list.map(_.purge(versions))
if (undo_list1.forall(_.isEmpty)) this
else new History(for ((a, b) <- undo_list1 zip undo_list) yield a.getOrElse(b))
}
}
/* snapshot: persistent user-view of document state */
object Snapshot
{
val init: Snapshot = State.init.snapshot()
}
class Snapshot private[Document](
val state: State,
val version: Version,
val node_name: Node.Name,
edits: List[Text.Edit],
val snippet_command: Option[Command])
{
override def toString: String =
"Snapshot(node = " + node_name.node + ", version = " + version.id +
(if (is_outdated) ", outdated" else "") + ")"
/* nodes */
def get_node(name: Node.Name): Node = version.nodes(name)
val node: Node = get_node(node_name)
def node_files: List[Node.Name] =
node_name :: node.load_commands.flatMap(_.blobs_names)
/* edits */
def is_outdated: Boolean = edits.nonEmpty
private lazy val reverse_edits = edits.reverse
def convert(offset: Text.Offset): Text.Offset =
(offset /: edits)((i, edit) => edit.convert(i))
def revert(offset: Text.Offset): Text.Offset =
(offset /: reverse_edits)((i, edit) => edit.revert(i))
def convert(range: Text.Range): Text.Range = range.map(convert)
def revert(range: Text.Range): Text.Range = range.map(revert)
/* theory load commands */
val commands_loading: List[Command] =
if (node_name.is_theory) Nil
else version.nodes.commands_loading(node_name)
def commands_loading_ranges(pred: Node.Name => Boolean): List[Text.Range] =
(for {
cmd <- node.load_commands.iterator
blob_name <- cmd.blobs_names.iterator
if pred(blob_name)
start <- node.command_start(cmd)
} yield convert(cmd.core_range + start)).toList
/* command as add-on snippet */
def snippet(command: Command): Snapshot =
{
val node_name = command.node_name
val nodes0 = version.nodes
val nodes1 = nodes0 + (node_name -> nodes0(node_name).update_commands(Linear_Set(command)))
val version1 = Document.Version.make(nodes1)
val edits: List[Edit_Text] =
List(node_name -> Node.Edits(List(Text.Edit.insert(0, command.source))))
val state0 = state.define_command(command)
val state1 =
state0.continue_history(Future.value(version), edits, Future.value(version1))
.define_version(version1, state0.the_assignment(version))
.assign(version1.id, Nil, List(command.id -> List(Document_ID.make())))._2
state1.snapshot(node_name = node_name, snippet_command = Some(command))
}
/* XML markup */
def xml_markup(
range: Text.Range = Text.Range.full,
elements: Markup.Elements = Markup.Elements.full): XML.Body =
state.xml_markup(version, node_name, range = range, elements = elements)
def xml_markup_blobs(elements: Markup.Elements = Markup.Elements.full)
: List[(Path, XML.Body)] =
{
snippet_command match {
case None => Nil
case Some(command) =>
for (Exn.Res(blob) <- command.blobs)
yield {
val bytes = blob.read_file
val text = bytes.text
val xml =
if (Bytes(text) == bytes) {
val markup = command.init_markups(Command.Markup_Index.blob(blob))
markup.to_XML(Text.Range(0, text.length), text, elements)
}
else Nil
blob.src_path -> xml
}
}
}
/* messages */
lazy val messages: List[(XML.Elem, Position.T)] =
(for {
(command, start) <-
Document.Node.Commands.starts_pos(
node.commands.iterator, Token.Pos.file(node_name.node))
pos = command.span.keyword_pos(start).position(command.span.name)
(_, elem) <- state.command_results(version, command).iterator
} yield (elem, pos)).toList
/* exports */
lazy val exports: List[Export.Entry] =
state.node_exports(version, node_name).iterator.map(_._2).toList
lazy val exports_map: Map[String, Export.Entry] =
(for (entry <- exports.iterator) yield (entry.name, entry)).toMap
/* find command */
def find_command(id: Document_ID.Generic): Option[(Node, Command)] =
state.lookup_id(id) match {
case None => None
case Some(st) =>
val command = st.command
val command_node = get_node(command.node_name)
if (command_node.commands.contains(command)) Some((command_node, command)) else None
}
def find_command_position(id: Document_ID.Generic, offset: Symbol.Offset)
: Option[Line.Node_Position] =
for ((node, command) <- find_command(id))
yield {
val name = command.node_name.node
val sources_iterator =
node.commands.iterator.takeWhile(_ != command).map(_.source) ++
(if (offset == 0) Iterator.empty
else Iterator.single(command.source(Text.Range(0, command.chunk.decode(offset)))))
val pos = (Line.Position.zero /: sources_iterator)(_.advance(_))
Line.Node_Position(name, pos)
}
def current_command(other_node_name: Node.Name, offset: Text.Offset): Option[Command] =
if (other_node_name.is_theory) {
val other_node = get_node(other_node_name)
val iterator = other_node.command_iterator(revert(offset) max 0)
if (iterator.hasNext) {
val (command0, _) = iterator.next
other_node.commands.reverse.iterator(command0).find(command => !command.is_ignored)
}
else other_node.commands.reverse.iterator.find(command => !command.is_ignored)
}
else version.nodes.commands_loading(other_node_name).headOption
/* command results */
def command_results(range: Text.Range): Command.Results =
Command.State.merge_results(
select[List[Command.State]](range, Markup.Elements.full, command_states =>
{ case _ => Some(command_states) }).flatMap(_.info))
def command_results(command: Command): Command.Results =
state.command_results(version, command)
/* command ids: static and dynamic */
def command_id_map: Map[Document_ID.Generic, Command] =
state.command_id_map(version, get_node(node_name).commands)
/* cumulate markup */
def cumulate[A](
range: Text.Range,
info: A,
elements: Markup.Elements,
result: List[Command.State] => (A, Text.Markup) => Option[A],
status: Boolean = false): List[Text.Info[A]] =
{
val former_range = revert(range).inflate_singularity
val (chunk_name, command_iterator) =
commands_loading.headOption match {
case None => (Symbol.Text_Chunk.Default, node.command_iterator(former_range))
case Some(command) => (Symbol.Text_Chunk.File(node_name.node), Iterator((command, 0)))
}
val markup_index = Command.Markup_Index(status, chunk_name)
(for {
(command, command_start) <- command_iterator
chunk <- command.chunks.get(chunk_name).iterator
states = state.command_states(version, command)
res = result(states)
markup_range <- (former_range - command_start).try_restrict(chunk.range).iterator
markup = Command.State.merge_markup(states, markup_index, markup_range, elements)
Text.Info(r0, a) <- markup.cumulate[A](markup_range, info, elements,
{
case (a, Text.Info(r0, b)) => res(a, Text.Info(convert(r0 + command_start), b))
}).iterator
r1 <- convert(r0 + command_start).try_restrict(range).iterator
} yield Text.Info(r1, a)).toList
}
def select[A](
range: Text.Range,
elements: Markup.Elements,
result: List[Command.State] => Text.Markup => Option[A],
status: Boolean = false): List[Text.Info[A]] =
{
def result1(states: List[Command.State]): (Option[A], Text.Markup) => Option[Option[A]] =
{
val res = result(states)
(_: Option[A], x: Text.Markup) =>
res(x) match {
case None => None
case some => Some(some)
}
}
for (Text.Info(r, Some(x)) <- cumulate(range, None, elements, result1, status))
yield Text.Info(r, x)
}
}
/* model */
trait Session
{
def resources: Resources
}
trait Model
{
def session: Session
def is_stable: Boolean
def snapshot(): Snapshot
def node_name: Node.Name
def is_theory: Boolean = node_name.is_theory
override def toString: String = node_name.toString
def get_text(range: Text.Range): Option[String]
def node_required: Boolean
def get_blob: Option[Blob]
def bibtex_entries: List[Text.Info[String]]
def node_edits(
node_header: Node.Header,
text_edits: List[Text.Edit],
perspective: Node.Perspective_Text): List[Edit_Text] =
{
val edits: List[Node.Edit[Text.Edit, Text.Perspective]] =
get_blob match {
case None =>
List(
Node.Deps(
if (session.resources.session_base.loaded_theory(node_name)) {
node_header.append_errors(
List("Cannot update finished theory " + quote(node_name.theory)))
}
else node_header),
Node.Edits(text_edits), perspective)
case Some(blob) => List(Node.Blob(blob), Node.Edits(text_edits))
}
edits.flatMap(edit => if (edit.is_void) None else Some(node_name -> edit))
}
}
/** global state -- document structure, execution process, editing history **/
type Assign_Update =
List[(Document_ID.Command, List[Document_ID.Exec])] // update of exec state assignment
object State
{
class Fail(state: State) extends Exception
object Assignment
{
val init: Assignment = new Assignment()
}
final class Assignment private(
val command_execs: Map[Document_ID.Command, List[Document_ID.Exec]] = Map.empty,
val is_finished: Boolean = false)
{
override def toString: String = "Assignment(" + command_execs.size + "," + is_finished + ")"
def check_finished: Assignment = { require(is_finished, "assignment not finished"); this }
def unfinished: Assignment = new Assignment(command_execs, false)
def assign(update: Assign_Update): Assignment =
{
require(!is_finished, "assignment already finished")
val command_execs1 =
(command_execs /: update) {
case (res, (command_id, exec_ids)) =>
if (exec_ids.isEmpty) res - command_id
else res + (command_id -> exec_ids)
}
new Assignment(command_execs1, true)
}
}
val init: State =
State().define_version(Version.init, Assignment.init).assign(Version.init.id, Nil, Nil)._2
}
final case class State private(
/*reachable versions*/
versions: Map[Document_ID.Version, Version] = Map.empty,
/*inlined auxiliary files*/
blobs: Set[SHA1.Digest] = Set.empty,
/*loaded theories in batch builds*/
theories: Map[Document_ID.Exec, Command.State] = Map.empty,
/*static markup from define_command*/
commands: Map[Document_ID.Command, Command.State] = Map.empty,
/*dynamic markup from execution*/
execs: Map[Document_ID.Exec, Command.State] = Map.empty,
/*command-exec assignment for each version*/
assignments: Map[Document_ID.Version, State.Assignment] = Map.empty,
/*commands with markup produced by other commands (imm_succs)*/
commands_redirection: Graph[Document_ID.Command, Unit] = Graph.long,
/*explicit (linear) history*/
history: History = History.init,
/*intermediate state between remove_versions/removed_versions*/
removing_versions: Boolean = false)
{
override def toString: String =
"State(versions = " + versions.size +
", blobs = " + blobs.size +
", commands = " + commands.size +
", execs = " + execs.size +
", assignments = " + assignments.size +
", commands_redirection = " + commands_redirection.size +
", history = " + history.undo_list.size +
", removing_versions = " + removing_versions + ")"
private def fail[A]: A = throw new State.Fail(this)
def define_version(version: Version, assignment: State.Assignment): State =
{
val id = version.id
copy(versions = versions + (id -> version),
assignments = assignments + (id -> assignment.unfinished))
}
def define_blob(digest: SHA1.Digest): State = copy(blobs = blobs + digest)
def defined_blob(digest: SHA1.Digest): Boolean = blobs.contains(digest)
def define_command(command: Command): State =
{
val id = command.id
if (commands.isDefinedAt(id)) fail
else copy(commands = commands + (id -> command.init_state))
}
def defined_command(id: Document_ID.Command): Boolean = commands.isDefinedAt(id)
def the_version(id: Document_ID.Version): Version = versions.getOrElse(id, fail)
def the_static_state(id: Document_ID.Command): Command.State = commands.getOrElse(id, fail)
def the_dynamic_state(id: Document_ID.Exec): Command.State = execs.getOrElse(id, fail)
def the_assignment(version: Version): State.Assignment = assignments.getOrElse(version.id, fail)
def lookup_id(id: Document_ID.Generic): Option[Command.State] =
theories.get(id) orElse commands.get(id) orElse execs.get(id)
private def self_id(st: Command.State)(id: Document_ID.Generic): Boolean =
id == st.command.id ||
(execs.get(id) match { case Some(st1) => st1.command.id == st.command.id case None => false })
private def other_id(node_name: Node.Name, id: Document_ID.Generic)
: Option[(Symbol.Text_Chunk.Id, Symbol.Text_Chunk)] =
{
for {
st <- lookup_id(id)
if st.command.node_name == node_name
} yield (Symbol.Text_Chunk.Id(st.command.id), st.command.chunk)
}
private def redirection(st: Command.State): Graph[Document_ID.Command, Unit] =
(commands_redirection /: st.markups.redirection_iterator)({ case (graph, id) =>
graph.default_node(id, ()).default_node(st.command.id, ()).add_edge(id, st.command.id) })
def accumulate(id: Document_ID.Generic, message: XML.Elem, cache: XML.Cache)
: (Command.State, State) =
{
def update(st: Command.State): (Command.State, State) =
{
val st1 = st.accumulate(self_id(st), other_id, message, cache)
(st1, copy(commands_redirection = redirection(st1)))
}
execs.get(id).map(update) match {
case Some((st1, state1)) => (st1, state1.copy(execs = execs + (id -> st1)))
case None =>
commands.get(id).map(update) match {
case Some((st1, state1)) => (st1, state1.copy(commands = commands + (id -> st1)))
case None =>
theories.get(id).map(update) match {
case Some((st1, state1)) => (st1, state1.copy(theories = theories + (id -> st1)))
case None => fail
}
}
}
}
def add_export(id: Document_ID.Generic, entry: Command.Exports.Entry): (Command.State, State) =
{
execs.get(id) match {
case Some(st) =>
st.add_export(entry) match {
case Some(new_st) => (new_st, copy(execs = execs + (id -> new_st)))
case None => fail
}
case None =>
commands.get(id) match {
case Some(st) =>
st.add_export(entry) match {
case Some(new_st) => (new_st, copy(commands = commands + (id -> new_st)))
case None => fail
}
case None => fail
}
}
}
def node_exports(version: Version, node_name: Node.Name): Command.Exports =
Command.Exports.merge(
for {
command <- version.nodes(node_name).commands.iterator
st <- command_states(version, command).iterator
} yield st.exports)
def begin_theory(
node_name: Node.Name,
id: Document_ID.Exec,
source: String,
blobs_info: Command.Blobs_Info): State =
{
if (theories.isDefinedAt(id)) fail
else {
val command =
Command.unparsed(source, theory = true, id = id, node_name = node_name,
blobs_info = blobs_info)
copy(theories = theories + (id -> command.empty_state))
}
}
def end_theory(id: Document_ID.Exec): (Snapshot, State) =
theories.get(id) match {
case None => fail
case Some(st) =>
val command = st.command
val node_name = command.node_name
val command1 =
Command.unparsed(command.source, theory = true, id = id, node_name = node_name,
blobs_info = command.blobs_info, results = st.results, markups = st.markups)
val state1 = copy(theories = theories - id)
(state1.snippet(command1), state1)
}
def assign(id: Document_ID.Version, edited: List[String], update: Assign_Update)
: ((List[Node.Name], List[Command]), State) =
{
val version = the_version(id)
val edited_set = edited.toSet
val edited_nodes =
(for { (name, _) <- version.nodes.iterator if edited_set(name.node) } yield name).toList
def upd(exec_id: Document_ID.Exec, st: Command.State)
: Option[(Document_ID.Exec, Command.State)] =
if (execs.isDefinedAt(exec_id)) None else Some(exec_id -> st)
val (changed_commands, new_execs) =
((Nil: List[Command], execs) /: update) {
case ((commands1, execs1), (command_id, exec)) =>
val st = the_static_state(command_id)
val command = st.command
val commands2 = command :: commands1
val execs2 =
exec match {
case Nil => execs1
case eval_id :: print_ids =>
execs1 ++ upd(eval_id, st) ++
(for (id <- print_ids; up <- upd(id, command.empty_state)) yield up)
}
(commands2, execs2)
}
val new_assignment = the_assignment(version).assign(update)
val new_state = copy(assignments = assignments + (id -> new_assignment), execs = new_execs)
((edited_nodes, changed_commands), new_state)
}
def is_assigned(version: Version): Boolean =
assignments.get(version.id) match {
case Some(assgn) => assgn.is_finished
case None => false
}
def is_stable(change: Change): Boolean =
change.is_finished && is_assigned(change.version.get_finished)
def recent_finished: Change = history.undo_list.find(_.is_finished) getOrElse fail
def recent_stable: Change = history.undo_list.find(is_stable) getOrElse fail
def stable_tip_version: Option[Version] =
if (is_stable(history.tip)) Some(history.tip.version.get_finished) else None
def continue_history(
previous: Future[Version],
edits: List[Edit_Text],
version: Future[Version]): State =
{
val change = Change.make(previous, edits, version)
copy(history = history + change)
}
def remove_versions(retain: Int = 0): (List[Version], State) =
{
history.prune(is_stable, retain) match {
case Some((dropped, history1)) =>
val old_versions = dropped.map(change => change.version.get_finished)
val removing = old_versions.nonEmpty
val state1 = copy(history = history1, removing_versions = removing)
(old_versions, state1)
case None => fail
}
}
def removed_versions(removed: List[Document_ID.Version]): State =
{
val versions1 = Version.purge_suppressed(versions -- removed)
val assignments1 = assignments -- removed
var blobs1_names = Set.empty[Node.Name]
var blobs1 = Set.empty[SHA1.Digest]
var commands1 = Map.empty[Document_ID.Command, Command.State]
var execs1 = Map.empty[Document_ID.Exec, Command.State]
for {
(version_id, version) <- versions1.iterator
command_execs = assignments1(version_id).command_execs
(_, node) <- version.nodes.iterator
command <- node.commands.iterator
} {
for ((name, digest) <- command.blobs_defined) {
blobs1_names += name
blobs1 += digest
}
if (!commands1.isDefinedAt(command.id))
commands.get(command.id).foreach(st => commands1 += (command.id -> st))
for (exec_id <- command_execs.getOrElse(command.id, Nil)) {
if (!execs1.isDefinedAt(exec_id))
execs.get(exec_id).foreach(st => execs1 += (exec_id -> st))
}
}
copy(
versions = versions1,
blobs = blobs1,
commands = commands1,
execs = execs1,
commands_redirection = commands_redirection.restrict(commands1.keySet),
assignments = assignments1,
history = history.purge(versions1),
removing_versions = false)
}
def command_id_map(version: Version, commands: Iterable[Command])
: Map[Document_ID.Generic, Command] =
{
require(is_assigned(version), "version not assigned (command_id_map)")
val assignment = the_assignment(version).check_finished
(for {
command <- commands.iterator
id <- (command.id :: assignment.command_execs.getOrElse(command.id, Nil)).iterator
} yield (id -> command)).toMap
}
def command_maybe_consolidated(version: Version, command: Command): Boolean =
{
require(is_assigned(version), "version not assigned (command_maybe_consolidated)")
try {
the_assignment(version).check_finished.command_execs.getOrElse(command.id, Nil) match {
case eval_id :: print_ids =>
the_dynamic_state(eval_id).maybe_consolidated &&
!print_ids.exists(print_id => the_dynamic_state(print_id).consolidating)
case Nil => false
}
}
catch { case _: State.Fail => false }
}
private def command_states_self(version: Version, command: Command)
: List[(Document_ID.Generic, Command.State)] =
{
require(is_assigned(version), "version not assigned (command_states_self)")
try {
the_assignment(version).check_finished.command_execs.getOrElse(command.id, Nil)
.map(id => id -> the_dynamic_state(id)) match {
case Nil => fail
case res => res
}
}
catch {
case _: State.Fail =>
try { List(command.id -> the_static_state(command.id)) }
catch { case _: State.Fail => List(command.id -> command.init_state) }
}
}
def command_states(version: Version, command: Command): List[Command.State] =
{
val self = command_states_self(version, command)
val others =
if (commands_redirection.defined(command.id)) {
(for {
command_id <- commands_redirection.imm_succs(command.id).iterator
(id, st) <- command_states_self(version, the_static_state(command_id).command)
if !self.exists(_._1 == id)
} yield (id, st)).toMap.valuesIterator.toList
}
else Nil
self.map(_._2) ::: others.flatMap(_.redirect(command))
}
def command_results(version: Version, command: Command): Command.Results =
Command.State.merge_results(command_states(version, command))
def command_markup(version: Version, command: Command, index: Command.Markup_Index,
range: Text.Range, elements: Markup.Elements): Markup_Tree =
Command.State.merge_markup(command_states(version, command), index, range, elements)
def xml_markup(
version: Version,
node_name: Node.Name,
range: Text.Range = Text.Range.full,
elements: Markup.Elements = Markup.Elements.full): XML.Body =
{
val node = version.nodes(node_name)
if (node_name.is_theory) {
val markup_index = Command.Markup_Index.markup
(for {
command <- node.commands.iterator
command_range <- command.range.try_restrict(range).iterator
markup = command_markup(version, command, markup_index, command_range, elements)
tree <- markup.to_XML(command_range, command.source, elements).iterator
} yield tree).toList
}
else {
val node_source = node.source
Text.Range(0, node_source.length).try_restrict(range) match {
case None => Nil
case Some(node_range) =>
val markup =
version.nodes.commands_loading(node_name).headOption match {
case None => Markup_Tree.empty
case Some(command) =>
val chunk_name = Symbol.Text_Chunk.File(node_name.node)
val markup_index = Command.Markup_Index(false, chunk_name)
command_markup(version, command, markup_index, node_range, elements)
}
markup.to_XML(node_range, node_source, elements)
}
}
}
def node_initialized(version: Version, name: Node.Name): Boolean =
name.is_theory &&
(version.nodes(name).commands.iterator.find(_.potentially_initialized) match {
case None => false
case Some(command) => command_states(version, command).headOption.exists(_.initialized)
})
def node_maybe_consolidated(version: Version, name: Node.Name): Boolean =
name.is_theory &&
version.nodes(name).commands.reverse.iterator.forall(command_maybe_consolidated(version, _))
def node_consolidated(version: Version, name: Node.Name): Boolean =
!name.is_theory ||
{
val it = version.nodes(name).commands.reverse.iterator
it.hasNext && command_states(version, it.next).exists(_.consolidated)
}
def snapshot(
node_name: Node.Name = Node.Name.empty,
pending_edits: List[Text.Edit] = Nil,
snippet_command: Option[Command] = None): Snapshot =
{
val stable = recent_stable
val version = stable.version.get_finished
val rev_pending_changes =
for {
change <- history.undo_list.takeWhile(_ != stable)
(name, edits) <- change.rev_edits
if name == node_name
} yield edits
val edits =
(pending_edits /: rev_pending_changes)({
case (edits, Node.Edits(es)) => es ::: edits
case (edits, _) => edits
})
new Snapshot(this, version, node_name, edits, snippet_command)
}
def snippet(command: Command): Snapshot =
snapshot().snippet(command)
}
}
diff --git a/src/Pure/PIDE/editor.scala b/src/Pure/PIDE/editor.scala
--- a/src/Pure/PIDE/editor.scala
+++ b/src/Pure/PIDE/editor.scala
@@ -1,53 +1,53 @@
/* Title: Pure/PIDE/editor.scala
Author: Makarius
General editor operations.
*/
package isabelle
abstract class Editor[Context]
{
/* session */
def session: Session
def flush(): Unit
def invoke(): Unit
/* current situation */
def current_node(context: Context): Option[Document.Node.Name]
def current_node_snapshot(context: Context): Option[Document.Snapshot]
def node_snapshot(name: Document.Node.Name): Document.Snapshot
def current_command(context: Context, snapshot: Document.Snapshot): Option[Command]
/* overlays */
def node_overlays(name: Document.Node.Name): Document.Node.Overlays
- def insert_overlay(command: Command, fn: String, args: List[String])
- def remove_overlay(command: Command, fn: String, args: List[String])
+ def insert_overlay(command: Command, fn: String, args: List[String]): Unit
+ def remove_overlay(command: Command, fn: String, args: List[String]): Unit
/* hyperlinks */
abstract class Hyperlink
{
def external: Boolean = false
def follow(context: Context): Unit
}
def hyperlink_command(
focus: Boolean, snapshot: Document.Snapshot, id: Document_ID.Generic, offset: Symbol.Offset = 0)
: Option[Hyperlink]
/* dispatcher thread */
def assert_dispatcher[A](body: => A): A
def require_dispatcher[A](body: => A): A
def send_dispatcher(body: => Unit): Unit
def send_wait_dispatcher(body: => Unit): Unit
}
diff --git a/src/Pure/PIDE/headless.scala b/src/Pure/PIDE/headless.scala
--- a/src/Pure/PIDE/headless.scala
+++ b/src/Pure/PIDE/headless.scala
@@ -1,661 +1,661 @@
/* Title: Pure/PIDE/headless.scala
Author: Makarius
Headless PIDE session and resources from file-system.
*/
package isabelle
import java.io.{File => JFile}
import scala.annotation.tailrec
import scala.collection.mutable
object Headless
{
/** session **/
private def stable_snapshot(
state: Document.State, version: Document.Version, name: Document.Node.Name): Document.Snapshot =
{
val snapshot = state.snapshot(name)
assert(version.id == snapshot.version.id)
snapshot
}
class Use_Theories_Result private[Headless](
val state: Document.State,
val version: Document.Version,
val nodes: List[(Document.Node.Name, Document_Status.Node_Status)],
val nodes_committed: List[(Document.Node.Name, Document_Status.Node_Status)])
{
def nodes_pending: List[(Document.Node.Name, Document_Status.Node_Status)] =
{
val committed = nodes_committed.iterator.map(_._1).toSet
nodes.filter(p => !committed(p._1))
}
def snapshot(name: Document.Node.Name): Document.Snapshot =
stable_snapshot(state, version, name)
def ok: Boolean =
(nodes.iterator ++ nodes_committed.iterator).forall({ case (_, st) => st.ok })
}
class Session private[Headless](
session_name: String,
_session_options: => Options,
override val resources: Resources) extends isabelle.Session(_session_options, resources)
{
session =>
private def loaded_theory(name: Document.Node.Name): Boolean =
resources.session_base.loaded_theory(name.theory)
/* options */
override def consolidate_delay: Time = session_options.seconds("headless_consolidate_delay")
override def prune_delay: Time = session_options.seconds("headless_prune_delay")
def default_check_delay: Time = session_options.seconds("headless_check_delay")
def default_check_limit: Int = session_options.int("headless_check_limit")
def default_nodes_status_delay: Time = session_options.seconds("headless_nodes_status_delay")
def default_watchdog_timeout: Time = session_options.seconds("headless_watchdog_timeout")
def default_commit_cleanup_delay: Time = session_options.seconds("headless_commit_cleanup_delay")
/* temporary directory */
val tmp_dir: JFile = Isabelle_System.tmp_dir("server_session")
val tmp_dir_name: String = File.path(tmp_dir).implode
def master_directory(master_dir: String): String =
proper_string(master_dir) getOrElse tmp_dir_name
override def toString: String = session_name
override def stop(): Process_Result =
{
try { super.stop() }
finally { Isabelle_System.rm_tree(tmp_dir) }
}
/* theories */
private object Load_State
{
def finished: Load_State = Load_State(Nil, Nil, 0)
def count_file(name: Document.Node.Name): Long =
if (loaded_theory(name)) 0 else name.path.file.length
}
private case class Load_State(
pending: List[Document.Node.Name], rest: List[Document.Node.Name], load_limit: Long)
{
def next(
dep_graph: Document.Node.Name.Graph[Unit],
finished: Document.Node.Name => Boolean): (List[Document.Node.Name], Load_State) =
{
def load_requirements(pending1: List[Document.Node.Name], rest1: List[Document.Node.Name])
: (List[Document.Node.Name], Load_State) =
{
val load_theories = dep_graph.all_preds_rev(pending1).filterNot(finished)
(load_theories, Load_State(pending1, rest1, load_limit))
}
if (!pending.forall(finished)) (Nil, this)
else if (rest.isEmpty) (Nil, Load_State.finished)
else if (load_limit == 0) load_requirements(rest, Nil)
else {
val reachable =
dep_graph.reachable_limit(load_limit, Load_State.count_file, dep_graph.imm_preds, rest)
val (pending1, rest1) = rest.partition(reachable)
load_requirements(pending1, rest1)
}
}
}
private sealed case class Use_Theories_State(
dep_graph: Document.Node.Name.Graph[Unit],
load_state: Load_State,
watchdog_timeout: Time,
commit: Option[(Document.Snapshot, Document_Status.Node_Status) => Unit],
last_update: Time = Time.now(),
nodes_status: Document_Status.Nodes_Status = Document_Status.Nodes_Status.empty,
already_committed: Map[Document.Node.Name, Document_Status.Node_Status] = Map.empty,
result: Option[Exn.Result[Use_Theories_Result]] = None)
{
def update(new_nodes_status: Document_Status.Nodes_Status): Use_Theories_State =
copy(last_update = Time.now(), nodes_status = new_nodes_status)
def watchdog: Boolean =
watchdog_timeout > Time.zero && Time.now() - last_update > watchdog_timeout
def finished_result: Boolean = result.isDefined
def join_result: Option[(Exn.Result[Use_Theories_Result], Use_Theories_State)] =
if (finished_result) Some((result.get, this)) else None
def cancel_result: Use_Theories_State =
if (finished_result) this else copy(result = Some(Exn.Exn(Exn.Interrupt())))
def clean_theories: (List[Document.Node.Name], Use_Theories_State) =
{
@tailrec def frontier(base: List[Document.Node.Name], front: Set[Document.Node.Name])
: Set[Document.Node.Name] =
{
val add = base.filter(name => dep_graph.imm_succs(name).forall(front))
if (add.isEmpty) front
else {
val preds = add.map(dep_graph.imm_preds)
val base1 = (preds.head /: preds.tail)(_ ++ _).toList.filter(already_committed.keySet)
frontier(base1, front ++ add)
}
}
if (already_committed.isEmpty) (Nil, this)
else {
val base =
(for {
(name, (_, (_, succs))) <- dep_graph.iterator
if succs.isEmpty && already_committed.isDefinedAt(name)
} yield name).toList
val clean = frontier(base, Set.empty)
if (clean.isEmpty) (Nil, this)
else {
(dep_graph.topological_order.filter(clean),
copy(dep_graph = dep_graph.exclude(clean)))
}
}
}
def check(state: Document.State, version: Document.Version, beyond_limit: Boolean)
: (List[Document.Node.Name], Use_Theories_State) =
{
val already_committed1 =
commit match {
case None => already_committed
case Some(commit_fn) =>
(already_committed /: dep_graph.topological_order)(
{ case (committed, name) =>
def parents_committed: Boolean =
version.nodes(name).header.imports.forall(parent =>
loaded_theory(parent) || committed.isDefinedAt(parent))
if (!committed.isDefinedAt(name) && parents_committed &&
state.node_consolidated(version, name))
{
val snapshot = stable_snapshot(state, version, name)
val status = Document_Status.Node_Status.make(state, version, name)
commit_fn(snapshot, status)
committed + (name -> status)
}
else committed
})
}
def finished_theory(name: Document.Node.Name): Boolean =
loaded_theory(name) ||
(if (commit.isDefined) already_committed1.isDefinedAt(name)
else state.node_consolidated(version, name))
val result1 =
if (!finished_result &&
(beyond_limit || watchdog ||
dep_graph.keys_iterator.forall(name =>
finished_theory(name) || nodes_status.quasi_consolidated(name))))
{
val nodes =
(for {
name <- dep_graph.keys_iterator
if !loaded_theory(name)
} yield { (name -> Document_Status.Node_Status.make(state, version, name)) }).toList
val nodes_committed =
(for {
name <- dep_graph.keys_iterator
status <- already_committed1.get(name)
} yield (name -> status)).toList
Some(Exn.Res(new Use_Theories_Result(state, version, nodes, nodes_committed)))
}
else result
val (load_theories, load_state1) = load_state.next(dep_graph, finished_theory)
(load_theories,
copy(already_committed = already_committed1, result = result1, load_state = load_state1))
}
}
def use_theories(
theories: List[String],
qualifier: String = Sessions.DRAFT,
master_dir: String = "",
unicode_symbols: Boolean = false,
check_delay: Time = default_check_delay,
check_limit: Int = default_check_limit,
watchdog_timeout: Time = default_watchdog_timeout,
nodes_status_delay: Time = default_nodes_status_delay,
id: UUID.T = UUID.random(),
// commit: must not block, must not fail
commit: Option[(Document.Snapshot, Document_Status.Node_Status) => Unit] = None,
commit_cleanup_delay: Time = default_commit_cleanup_delay,
progress: Progress = new Progress): Use_Theories_Result =
{
val dependencies =
{
val import_names =
theories.map(thy =>
resources.import_name(qualifier, master_directory(master_dir), thy) -> Position.none)
resources.dependencies(import_names, progress = progress).check_errors
}
val dep_theories = dependencies.theories
val dep_theories_set = dep_theories.toSet
val dep_files =
for (path <- dependencies.loaded_files)
yield Document.Node.Name(resources.append("", path))
val use_theories_state =
{
val dep_graph = dependencies.theory_graph
val maximals = dep_graph.maximals
val rest =
if (maximals.isEmpty || maximals.tail.isEmpty) maximals
else {
val depth = dep_graph.node_depth(Load_State.count_file)
maximals.sortBy(node => - depth(node))
}
val load_limit =
if (commit.isDefined) (session_options.real("headless_load_limit") * 1024 * 1024).round
else 0
val load_state = Load_State(Nil, rest, load_limit)
Synchronized(Use_Theories_State(dep_graph, load_state, watchdog_timeout, commit))
}
- def check_state(beyond_limit: Boolean = false)
+ def check_state(beyond_limit: Boolean = false): Unit =
{
val state = session.get_state()
for {
version <- state.stable_tip_version
load_theories = use_theories_state.change_result(_.check(state, version, beyond_limit))
if load_theories.nonEmpty
} resources.load_theories(session, id, load_theories, dep_files, unicode_symbols, progress)
}
val check_progress =
{
var check_count = 0
Event_Timer.request(Time.now(), repeat = Some(check_delay))
{
if (progress.stopped) use_theories_state.change(_.cancel_result)
else {
check_count += 1
check_state(check_limit > 0 && check_count > check_limit)
}
}
}
val consumer =
{
val delay_nodes_status =
Delay.first(nodes_status_delay max Time.zero) {
progress.nodes_status(use_theories_state.value.nodes_status)
}
val delay_commit_clean =
Delay.first(commit_cleanup_delay max Time.zero) {
val clean_theories = use_theories_state.change_result(_.clean_theories)
if (clean_theories.nonEmpty) {
progress.echo("Removing " + clean_theories.length + " theories ...")
resources.clean_theories(session, id, clean_theories)
}
}
Session.Consumer[Session.Commands_Changed](getClass.getName) {
case changed =>
if (changed.nodes.exists(dep_theories_set)) {
val snapshot = session.snapshot()
val state = snapshot.state
val version = snapshot.version
val theory_progress =
use_theories_state.change_result(st =>
{
val domain =
if (st.nodes_status.is_empty) dep_theories_set
else changed.nodes.iterator.filter(dep_theories_set).toSet
val (nodes_status_changed, nodes_status1) =
st.nodes_status.update(resources, state, version,
domain = Some(domain), trim = changed.assignment)
if (nodes_status_delay >= Time.zero && nodes_status_changed) {
delay_nodes_status.invoke
}
val theory_progress =
(for {
(name, node_status) <- nodes_status1.present.iterator
if changed.nodes.contains(name) && !st.already_committed.isDefinedAt(name)
p1 = node_status.percentage
if p1 > 0 && Some(p1) != st.nodes_status.get(name).map(_.percentage)
} yield Progress.Theory(name.theory, percentage = Some(p1))).toList
(theory_progress, st.update(nodes_status1))
})
theory_progress.foreach(progress.theory)
check_state()
if (commit.isDefined && commit_cleanup_delay > Time.zero) {
if (use_theories_state.value.finished_result)
delay_commit_clean.revoke
else delay_commit_clean.invoke
}
}
}
}
try {
session.commands_changed += consumer
check_state()
use_theories_state.guarded_access(_.join_result)
check_progress.cancel
}
finally {
session.commands_changed -= consumer
resources.unload_theories(session, id, dep_theories)
}
Exn.release(use_theories_state.guarded_access(_.join_result))
}
def purge_theories(
theories: List[String],
qualifier: String = Sessions.DRAFT,
master_dir: String = "",
all: Boolean = false): (List[Document.Node.Name], List[Document.Node.Name]) =
{
val nodes =
if (all) None
else Some(theories.map(resources.import_name(qualifier, master_directory(master_dir), _)))
resources.purge_theories(session, nodes)
}
}
/** resources **/
object Resources
{
def apply(options: Options, base_info: Sessions.Base_Info, log: Logger = No_Logger): Resources =
new Resources(options, base_info, log = log)
def make(
options: Options,
session_name: String,
session_dirs: List[Path] = Nil,
include_sessions: List[String] = Nil,
progress: Progress = new Progress,
log: Logger = No_Logger): Resources =
{
val base_info =
Sessions.base_info(options, session_name, dirs = session_dirs,
include_sessions = include_sessions, progress = progress)
apply(options, base_info, log = log)
}
final class Theory private[Headless](
val node_name: Document.Node.Name,
val node_header: Document.Node.Header,
val text: String,
val node_required: Boolean)
{
override def toString: String = node_name.toString
def node_perspective: Document.Node.Perspective_Text =
Document.Node.Perspective(node_required, Text.Perspective.empty, Document.Node.Overlays.empty)
def make_edits(text_edits: List[Text.Edit]): List[Document.Edit_Text] =
List(node_name -> Document.Node.Deps(node_header),
node_name -> Document.Node.Edits(text_edits),
node_name -> node_perspective)
def node_edits(old: Option[Theory]): List[Document.Edit_Text] =
{
val (text_edits, old_required) =
if (old.isEmpty) (Text.Edit.inserts(0, text), false)
else (Text.Edit.replace(0, old.get.text, text), old.get.node_required)
if (text_edits.isEmpty && node_required == old_required) Nil
else make_edits(text_edits)
}
def purge_edits: List[Document.Edit_Text] =
make_edits(Text.Edit.removes(0, text))
def required(required: Boolean): Theory =
if (required == node_required) this
else new Theory(node_name, node_header, text, required)
}
sealed case class State(
blobs: Map[Document.Node.Name, Document.Blob] = Map.empty,
theories: Map[Document.Node.Name, Theory] = Map.empty,
required: Multi_Map[Document.Node.Name, UUID.T] = Multi_Map.empty)
{
/* blobs */
def doc_blobs: Document.Blobs = Document.Blobs(blobs)
def update_blobs(names: List[Document.Node.Name]): (Document.Blobs, State) =
{
val new_blobs =
names.flatMap(name =>
{
val bytes = Bytes.read(name.path)
def new_blob: Document.Blob =
{
val text = bytes.text
Document.Blob(bytes, text, Symbol.Text_Chunk(text), changed = true)
}
blobs.get(name) match {
case Some(blob) => if (blob.bytes == bytes) None else Some(name -> new_blob)
case None => Some(name -> new_blob)
}
})
val blobs1 = (blobs /: new_blobs)(_ + _)
val blobs2 = (blobs /: new_blobs)({ case (map, (a, b)) => map + (a -> b.unchanged) })
(Document.Blobs(blobs1), copy(blobs = blobs2))
}
def blob_edits(name: Document.Node.Name, old_blob: Option[Document.Blob])
: List[Document.Edit_Text] =
{
val blob = blobs.getOrElse(name, error("Missing blob " + quote(name.toString)))
val text_edits =
old_blob match {
case None => List(Text.Edit.insert(0, blob.source))
case Some(blob0) => Text.Edit.replace(0, blob0.source, blob.source)
}
if (text_edits.isEmpty) Nil
else List(name -> Document.Node.Blob(blob), name -> Document.Node.Edits(text_edits))
}
/* theories */
lazy val theory_graph: Document.Node.Name.Graph[Unit] =
Document.Node.Name.make_graph(
for ((name, theory) <- theories.toList)
yield ((name, ()), theory.node_header.imports.filter(theories.isDefinedAt)))
def is_required(name: Document.Node.Name): Boolean = required.isDefinedAt(name)
def insert_required(id: UUID.T, names: List[Document.Node.Name]): State =
copy(required = (required /: names)(_.insert(_, id)))
def remove_required(id: UUID.T, names: List[Document.Node.Name]): State =
copy(required = (required /: names)(_.remove(_, id)))
def update_theories(update: List[(Document.Node.Name, Theory)]): State =
copy(theories =
(theories /: update)({ case (thys, (name, thy)) =>
thys.get(name) match {
case Some(thy1) if thy1 == thy => thys
case _ => thys + (name -> thy)
}
}))
def remove_theories(remove: List[Document.Node.Name]): State =
{
require(remove.forall(name => !is_required(name)), "attempt to remove required nodes")
copy(theories = theories -- remove)
}
def unload_theories(session: Session, id: UUID.T, theories: List[Document.Node.Name])
: (List[Document.Edit_Text], State) =
{
val st1 = remove_required(id, theories)
val theory_edits =
for {
node_name <- theories
theory <- st1.theories.get(node_name)
}
yield {
val theory1 = theory.required(st1.is_required(node_name))
val edits = theory1.node_edits(Some(theory))
(edits, (node_name, theory1))
}
(theory_edits.flatMap(_._1), st1.update_theories(theory_edits.map(_._2)))
}
def purge_theories(session: Session, nodes: Option[List[Document.Node.Name]])
: ((List[Document.Node.Name], List[Document.Node.Name], List[Document.Edit_Text]), State) =
{
val all_nodes = theory_graph.topological_order
val purge = nodes.getOrElse(all_nodes).filterNot(is_required).toSet
val retain = theory_graph.all_preds(all_nodes.filterNot(purge)).toSet
val (retained, purged) = all_nodes.partition(retain)
val purge_edits = purged.flatMap(name => theories(name).purge_edits)
((purged, retained, purge_edits), remove_theories(purged))
}
}
}
class Resources private[Headless](
val options: Options,
val session_base_info: Sessions.Base_Info,
log: Logger = No_Logger)
extends isabelle.Resources(
session_base_info.sessions_structure, session_base_info.check.base, log = log)
{
resources =>
val store: Sessions.Store = Sessions.store(options)
/* session */
def start_session(print_mode: List[String] = Nil, progress: Progress = new Progress): Session =
{
val session = new Session(session_base_info.session, options, resources)
progress.echo("Starting session " + session_base_info.session + " ...")
Isabelle_Process(session, options, session_base_info.sessions_structure, store,
logic = session_base_info.session, modes = print_mode).await_startup
session
}
/* theories */
private val state = Synchronized(Resources.State())
def load_theories(
session: Session,
id: UUID.T,
theories: List[Document.Node.Name],
files: List[Document.Node.Name],
unicode_symbols: Boolean,
- progress: Progress)
+ progress: Progress): Unit =
{
val loaded_theories =
for (node_name <- theories)
yield {
val path = node_name.path
if (!node_name.is_theory) error("Not a theory file: " + path)
progress.expose_interrupt()
val text0 = File.read(path)
val text = if (unicode_symbols) Symbol.decode(text0) else text0
val node_header = resources.check_thy(node_name, Scan.char_reader(text))
new Resources.Theory(node_name, node_header, text, true)
}
val loaded = loaded_theories.length
if (loaded > 1) progress.echo("Loading " + loaded + " theories ...")
state.change(st =>
{
val (doc_blobs1, st1) = st.insert_required(id, theories).update_blobs(files)
val theory_edits =
for (theory <- loaded_theories)
yield {
val node_name = theory.node_name
val theory1 = theory.required(st1.is_required(node_name))
val edits = theory1.node_edits(st1.theories.get(node_name))
(edits, (node_name, theory1))
}
val file_edits =
for { node_name <- files if doc_blobs1.changed(node_name) }
yield st1.blob_edits(node_name, st.blobs.get(node_name))
session.update(doc_blobs1, theory_edits.flatMap(_._1) ::: file_edits.flatten)
st1.update_theories(theory_edits.map(_._2))
})
}
- def unload_theories(session: Session, id: UUID.T, theories: List[Document.Node.Name])
+ def unload_theories(session: Session, id: UUID.T, theories: List[Document.Node.Name]): Unit =
{
state.change(st =>
{
val (edits, st1) = st.unload_theories(session, id, theories)
session.update(st.doc_blobs, edits)
st1
})
}
- def clean_theories(session: Session, id: UUID.T, theories: List[Document.Node.Name])
+ def clean_theories(session: Session, id: UUID.T, theories: List[Document.Node.Name]): Unit =
{
state.change(st =>
{
val (edits1, st1) = st.unload_theories(session, id, theories)
val ((_, _, edits2), st2) = st1.purge_theories(session, None)
session.update(st.doc_blobs, edits1 ::: edits2)
st2
})
}
def purge_theories(session: Session, nodes: Option[List[Document.Node.Name]])
: (List[Document.Node.Name], List[Document.Node.Name]) =
{
state.change_result(st =>
{
val ((purged, retained, _), st1) = st.purge_theories(session, nodes)
((purged, retained), st1)
})
}
}
}
diff --git a/src/Pure/PIDE/protocol.scala b/src/Pure/PIDE/protocol.scala
--- a/src/Pure/PIDE/protocol.scala
+++ b/src/Pure/PIDE/protocol.scala
@@ -1,449 +1,449 @@
/* Title: Pure/PIDE/protocol.scala
Author: Makarius
Protocol message formats for interactive proof documents.
*/
package isabelle
object Protocol
{
/* markers for inlined messages */
val Loading_Theory_Marker = Protocol_Message.Marker("loading_theory")
val Meta_Info_Marker = Protocol_Message.Marker("meta_info")
val Command_Timing_Marker = Protocol_Message.Marker("command_timing")
val Theory_Timing_Marker = Protocol_Message.Marker("theory_timing")
val Session_Timing_Marker = Protocol_Message.Marker("session_timing")
val ML_Statistics_Marker = Protocol_Message.Marker("ML_statistics")
val Task_Statistics_Marker = Protocol_Message.Marker("task_statistics")
val Error_Message_Marker = Protocol_Message.Marker("error_message")
/* batch build */
object Loading_Theory
{
def unapply(props: Properties.T): Option[(Document.Node.Name, Document_ID.Exec)] =
(props, props, props) match {
case (Markup.Name(name), Position.File(file), Position.Id(id))
if Path.is_wellformed(file) =>
val master_dir = Path.explode(file).dir.implode
Some((Document.Node.Name(file, master_dir, name), id))
case _ => None
}
}
/* document editing */
object Commands_Accepted
{
def unapply(text: String): Option[List[Document_ID.Command]] =
try { Some(space_explode(',', text).map(Value.Long.parse)) }
catch { case ERROR(_) => None }
val message: XML.Elem = XML.elem(Markup.STATUS, List(XML.elem(Markup.ACCEPTED)))
}
object Assign_Update
{
def unapply(text: String)
: Option[(Document_ID.Version, List[String], Document.Assign_Update)] =
{
try {
import XML.Decode._
def decode_upd(body: XML.Body): (Long, List[Long]) =
space_explode(',', string(body)).map(Value.Long.parse) match {
case a :: bs => (a, bs)
case _ => throw new XML.XML_Body(body)
}
Some(triple(long, list(string), list(decode_upd))(Symbol.decode_yxml(text)))
}
catch {
case ERROR(_) => None
case _: XML.Error => None
}
}
}
object Removed
{
def unapply(text: String): Option[List[Document_ID.Version]] =
try {
import XML.Decode._
Some(list(long)(Symbol.decode_yxml(text)))
}
catch {
case ERROR(_) => None
case _: XML.Error => None
}
}
/* command timing */
object Command_Timing
{
def unapply(props: Properties.T): Option[(Properties.T, Document_ID.Generic, isabelle.Timing)] =
props match {
case Markup.Command_Timing(args) =>
(args, args) match {
case (Position.Id(id), Markup.Timing_Properties(timing)) => Some((args, id, timing))
case _ => None
}
case _ => None
}
}
/* theory timing */
object Theory_Timing
{
def unapply(props: Properties.T): Option[(String, isabelle.Timing)] =
props match {
case Markup.Theory_Timing(args) =>
(args, args) match {
case (Markup.Name(name), Markup.Timing_Properties(timing)) => Some((name, timing))
case _ => None
}
case _ => None
}
}
/* result messages */
def is_result(msg: XML.Tree): Boolean =
msg match {
case XML.Elem(Markup(Markup.RESULT, _), _) => true
case _ => false
}
def is_tracing(msg: XML.Tree): Boolean =
msg match {
case XML.Elem(Markup(Markup.TRACING, _), _) => true
case XML.Elem(Markup(Markup.TRACING_MESSAGE, _), _) => true
case _ => false
}
def is_state(msg: XML.Tree): Boolean =
msg match {
case XML.Elem(Markup(Markup.STATE, _), _) => true
case XML.Elem(Markup(Markup.STATE_MESSAGE, _), _) => true
case _ => false
}
def is_information(msg: XML.Tree): Boolean =
msg match {
case XML.Elem(Markup(Markup.INFORMATION, _), _) => true
case XML.Elem(Markup(Markup.INFORMATION_MESSAGE, _), _) => true
case _ => false
}
def is_writeln(msg: XML.Tree): Boolean =
msg match {
case XML.Elem(Markup(Markup.WRITELN, _), _) => true
case XML.Elem(Markup(Markup.WRITELN_MESSAGE, _), _) => true
case _ => false
}
def is_warning(msg: XML.Tree): Boolean =
msg match {
case XML.Elem(Markup(Markup.WARNING, _), _) => true
case XML.Elem(Markup(Markup.WARNING_MESSAGE, _), _) => true
case _ => false
}
def is_legacy(msg: XML.Tree): Boolean =
msg match {
case XML.Elem(Markup(Markup.LEGACY, _), _) => true
case XML.Elem(Markup(Markup.LEGACY_MESSAGE, _), _) => true
case _ => false
}
def is_error(msg: XML.Tree): Boolean =
msg match {
case XML.Elem(Markup(Markup.ERROR, _), _) => true
case XML.Elem(Markup(Markup.ERROR_MESSAGE, _), _) => true
case _ => false
}
def is_inlined(msg: XML.Tree): Boolean =
!(is_result(msg) || is_tracing(msg) || is_state(msg))
def is_exported(msg: XML.Tree): Boolean =
is_writeln(msg) || is_warning(msg) || is_legacy(msg) || is_error(msg)
def message_text(elem: XML.Elem,
heading: Boolean = false,
pos: Position.T = Position.none,
margin: Double = Pretty.default_margin,
breakgain: Double = Pretty.default_breakgain,
metric: Pretty.Metric = Pretty.Default_Metric): String =
{
val text1 =
if (heading) {
val h =
if (is_warning(elem) || is_legacy(elem)) "Warning"
else if (is_error(elem)) "Error"
else if (is_information(elem)) "Information"
else if (is_tracing(elem)) "Tracing"
else if (is_state(elem)) "State"
else "Output"
"\n" + h + Position.here(pos) + ":\n"
}
else ""
val body =
Pretty.string_of(Protocol_Message.expose_no_reports(List(elem)),
margin = margin, breakgain = breakgain, metric = metric)
val text2 =
if (is_warning(elem) || is_legacy(elem)) Output.warning_prefix(body)
else if (is_error(elem)) Output.error_prefix(body)
else body
text1 + text2
}
/* export */
object Export
{
sealed case class Args(
id: Option[String] = None,
serial: Long = 0L,
theory_name: String,
name: String,
executable: Boolean = false,
compress: Boolean = true,
strict: Boolean = true)
{
def compound_name: String = isabelle.Export.compound_name(theory_name, name)
}
def unapply(props: Properties.T): Option[Args] =
props match {
case
List(
(Markup.FUNCTION, Markup.EXPORT),
(Markup.ID, id),
(Markup.SERIAL, Value.Long(serial)),
(Markup.THEORY_NAME, theory_name),
(Markup.NAME, name),
(Markup.EXECUTABLE, Value.Boolean(executable)),
(Markup.COMPRESS, Value.Boolean(compress)),
(Markup.STRICT, Value.Boolean(strict))) =>
Some(Args(proper_string(id), serial, theory_name, name, executable, compress, strict))
case _ => None
}
}
/* breakpoints */
object ML_Breakpoint
{
def unapply(tree: XML.Tree): Option[Long] =
tree match {
case XML.Elem(Markup(Markup.ML_BREAKPOINT, Markup.Serial(breakpoint)), _) => Some(breakpoint)
case _ => None
}
}
/* dialogs */
object Dialog_Args
{
def unapply(props: Properties.T): Option[(Document_ID.Generic, Long, String)] =
(props, props, props) match {
case (Position.Id(id), Markup.Serial(serial), Markup.Result(result)) =>
Some((id, serial, result))
case _ => None
}
}
object Dialog
{
def unapply(tree: XML.Tree): Option[(Document_ID.Generic, Long, String)] =
tree match {
case XML.Elem(Markup(Markup.DIALOG, Dialog_Args(id, serial, result)), _) =>
Some((id, serial, result))
case _ => None
}
}
object Dialog_Result
{
def apply(id: Document_ID.Generic, serial: Long, result: String): XML.Elem =
{
val props = Position.Id(id) ::: Markup.Serial(serial)
XML.Elem(Markup(Markup.RESULT, props), List(XML.Text(result)))
}
def unapply(tree: XML.Tree): Option[String] =
tree match {
case XML.Elem(Markup(Markup.RESULT, _), List(XML.Text(result))) => Some(result)
case _ => None
}
}
}
trait Protocol
{
/* protocol commands */
def protocol_command_raw(name: String, args: List[Bytes]): Unit
- def protocol_command_args(name: String, args: List[String])
+ def protocol_command_args(name: String, args: List[String]): Unit
def protocol_command(name: String, args: String*): Unit
/* options */
def options(opts: Options): Unit =
protocol_command("Prover.options", Symbol.encode_yxml(opts.encode))
/* resources */
def init_session(resources: Resources): Unit =
protocol_command("Prover.init_session", resources.init_session_yxml)
/* interned items */
def define_blob(digest: SHA1.Digest, bytes: Bytes): Unit =
protocol_command_raw("Document.define_blob", List(Bytes(digest.toString), bytes))
private def encode_command(resources: Resources, command: Command)
: (String, String, String, String, String, List[String]) =
{
import XML.Encode._
val parents = command.theory_parents(resources).map(name => File.standard_url(name.node))
val parents_yxml = Symbol.encode_yxml(list(string)(parents))
val blobs_yxml =
{
val encode_blob: T[Exn.Result[Command.Blob]] =
variant(List(
{ case Exn.Res(Command.Blob(a, b, c)) =>
(Nil, triple(string, string, option(string))(
(a.node, b.implode, c.map(p => p._1.toString)))) },
{ case Exn.Exn(e) => (Nil, string(Exn.message(e))) }))
Symbol.encode_yxml(pair(list(encode_blob), int)(command.blobs, command.blobs_index))
}
val toks_yxml =
{
val encode_tok: T[Token] = (tok => pair(int, int)((tok.kind.id, Symbol.length(tok.source))))
Symbol.encode_yxml(list(encode_tok)(command.span.content))
}
val toks_sources = command.span.content.map(tok => Symbol.encode(tok.source))
(Document_ID(command.id), Symbol.encode(command.span.name), parents_yxml,
blobs_yxml, toks_yxml, toks_sources)
}
- def define_command(resources: Resources, command: Command)
+ def define_command(resources: Resources, command: Command): Unit =
{
val (command_id, name, parents_yxml, blobs_yxml, toks_yxml, toks_sources) =
encode_command(resources, command)
protocol_command_args(
"Document.define_command", command_id :: name :: parents_yxml :: blobs_yxml ::
toks_yxml :: toks_sources)
}
- def define_commands(resources: Resources, commands: List[Command])
+ def define_commands(resources: Resources, commands: List[Command]): Unit =
{
protocol_command_args("Document.define_commands",
commands.map(command =>
{
import XML.Encode._
val (command_id, name, parents_yxml, blobs_yxml, toks_yxml, toks_sources) =
encode_command(resources, command)
val body =
pair(string, pair(string, pair(string, pair(string, pair(string, list(string))))))(
command_id, (name, (parents_yxml, (blobs_yxml, (toks_yxml, toks_sources)))))
YXML.string_of_body(body)
}))
}
- def define_commands_bulk(resources: Resources, commands: List[Command])
+ def define_commands_bulk(resources: Resources, commands: List[Command]): Unit =
{
val (irregular, regular) = commands.partition(command => YXML.detect(command.source))
irregular.foreach(define_command(resources, _))
regular match {
case Nil =>
case List(command) => define_command(resources, command)
case _ => define_commands(resources, regular)
}
}
/* execution */
def discontinue_execution(): Unit =
protocol_command("Document.discontinue_execution")
def cancel_exec(id: Document_ID.Exec): Unit =
protocol_command("Document.cancel_exec", Document_ID(id))
/* document versions */
def update(old_id: Document_ID.Version, new_id: Document_ID.Version,
- edits: List[Document.Edit_Command], consolidate: List[Document.Node.Name])
+ edits: List[Document.Edit_Command], consolidate: List[Document.Node.Name]): Unit =
{
val consolidate_yxml =
{
import XML.Encode._
Symbol.encode_yxml(list(string)(consolidate.map(_.node)))
}
val edits_yxml =
{
import XML.Encode._
def id: T[Command] = (cmd => long(cmd.id))
def encode_edit(name: Document.Node.Name)
: T[Document.Node.Edit[Command.Edit, Command.Perspective]] =
variant(List(
{ case Document.Node.Edits(a) => (Nil, list(pair(option(id), option(id)))(a)) },
{ case Document.Node.Deps(header) =>
val master_dir = File.standard_url(name.master_dir)
val imports = header.imports.map(_.node)
val keywords = header.keywords.map({ case (a, spec) => (a, (spec.kind, spec.tags)) })
(Nil,
pair(string, pair(string, pair(list(string),
pair(list(pair(string, pair(string, list(string)))), list(string)))))(
(master_dir, (name.theory, (imports, (keywords, header.errors)))))) },
{ case Document.Node.Perspective(a, b, c) =>
(bool_atom(a) :: b.commands.map(cmd => long_atom(cmd.id)),
list(pair(id, pair(string, list(string))))(c.dest)) }))
edits.map({ case (name, edit) =>
Symbol.encode_yxml(pair(string, encode_edit(name))(name.node, edit)) })
}
protocol_command_args("Document.update",
Document_ID(old_id) :: Document_ID(new_id) :: consolidate_yxml :: edits_yxml)
}
- def remove_versions(versions: List[Document.Version])
+ def remove_versions(versions: List[Document.Version]): Unit =
{
val versions_yxml =
{ import XML.Encode._
Symbol.encode_yxml(list(long)(versions.map(_.id))) }
protocol_command("Document.remove_versions", versions_yxml)
}
/* dialog via document content */
def dialog_result(serial: Long, result: String): Unit =
protocol_command("Document.dialog_result", Value.Long(serial), result)
}
diff --git a/src/Pure/PIDE/prover.scala b/src/Pure/PIDE/prover.scala
--- a/src/Pure/PIDE/prover.scala
+++ b/src/Pure/PIDE/prover.scala
@@ -1,368 +1,368 @@
/* Title: Pure/PIDE/prover.scala
Author: Makarius
Options: :folding=explicit:
Prover process wrapping.
*/
package isabelle
import java.io.{InputStream, OutputStream, BufferedOutputStream, IOException}
object Prover
{
/* messages */
sealed abstract class Message
type Receiver = Message => Unit
class Input(val name: String, val args: List[String]) extends Message
{
override def toString: String =
XML.Elem(Markup(Markup.PROVER_COMMAND, List((Markup.NAME, name))),
args.flatMap(s =>
List(XML.newline, XML.elem(Markup.PROVER_ARG, YXML.parse_body(s))))).toString
}
class Output(val message: XML.Elem) extends Message
{
def kind: String = message.markup.name
def properties: Properties.T = message.markup.properties
def body: XML.Body = message.body
def is_init: Boolean = kind == Markup.INIT
def is_exit: Boolean = kind == Markup.EXIT
def is_stdout: Boolean = kind == Markup.STDOUT
def is_stderr: Boolean = kind == Markup.STDERR
def is_system: Boolean = kind == Markup.SYSTEM
def is_status: Boolean = kind == Markup.STATUS
def is_report: Boolean = kind == Markup.REPORT
def is_syslog: Boolean = is_init || is_exit || is_system || is_stderr
override def toString: String =
{
val res =
if (is_status || is_report) message.body.map(_.toString).mkString
else Pretty.string_of(message.body, metric = Symbol.Metric)
if (properties.isEmpty)
kind.toString + " [[" + res + "]]"
else
kind.toString + " " +
(for ((x, y) <- properties) yield x + "=" + y).mkString("{", ",", "}") + " [[" + res + "]]"
}
}
class Protocol_Output(props: Properties.T, val bytes: Bytes)
extends Output(XML.Elem(Markup(Markup.PROTOCOL, props), Nil))
{
lazy val text: String = bytes.text
}
}
class Prover(
receiver: Prover.Receiver,
cache: XML.Cache,
channel: System_Channel,
process: Bash.Process) extends Protocol
{
/** receiver output **/
- private def system_output(text: String)
+ private def system_output(text: String): Unit =
{
receiver(new Prover.Output(XML.Elem(Markup(Markup.SYSTEM, Nil), List(XML.Text(text)))))
}
- private def protocol_output(props: Properties.T, bytes: Bytes)
+ private def protocol_output(props: Properties.T, bytes: Bytes): Unit =
{
receiver(new Prover.Protocol_Output(cache.props(props), bytes))
}
- private def output(kind: String, props: Properties.T, body: XML.Body)
+ private def output(kind: String, props: Properties.T, body: XML.Body): Unit =
{
val main = XML.Elem(Markup(kind, props), Protocol_Message.clean_reports(body))
val reports = Protocol_Message.reports(props, body)
for (msg <- main :: reports) receiver(new Prover.Output(cache.elem(msg)))
}
- private def exit_message(result: Process_Result)
+ private def exit_message(result: Process_Result): Unit =
{
output(Markup.EXIT, Markup.Process_Result(result),
List(XML.Text(result.print_return_code)))
}
/** process manager **/
private val process_result: Future[Process_Result] =
Future.thread("process_result") {
val rc = process.join
val timing = process.get_timing
Process_Result(rc, timing = timing)
}
- private def terminate_process()
+ private def terminate_process(): Unit =
{
try { process.terminate }
catch {
case exn @ ERROR(_) => system_output("Failed to terminate prover process: " + exn.getMessage)
}
}
private val process_manager = Isabelle_Thread.fork(name = "process_manager")
{
val stdout = physical_output(false)
val (startup_failed, startup_errors) =
{
var finished: Option[Boolean] = None
val result = new StringBuilder(100)
while (finished.isEmpty && (process.stderr.ready || !process_result.is_finished)) {
while (finished.isEmpty && process.stderr.ready) {
try {
val c = process.stderr.read
if (c == 2) finished = Some(true)
else result += c.toChar
}
catch { case _: IOException => finished = Some(false) }
}
Time.seconds(0.05).sleep
}
(finished.isEmpty || !finished.get, result.toString.trim)
}
if (startup_errors != "") system_output(startup_errors)
if (startup_failed) {
terminate_process()
process_result.join
stdout.join
exit_message(Process_Result(127))
}
else {
val (command_stream, message_stream) = channel.rendezvous()
command_input_init(command_stream)
val stderr = physical_output(true)
val message = message_output(message_stream)
val result = process_result.join
system_output("process terminated")
command_input_close()
for (thread <- List(stdout, stderr, message)) thread.join
system_output("process_manager terminated")
exit_message(result)
}
channel.shutdown()
}
/* management methods */
- def join() { process_manager.join() }
+ def join(): Unit = process_manager.join()
- def terminate()
+ def terminate(): Unit =
{
system_output("Terminating prover process")
command_input_close()
var count = 10
while (!process_result.is_finished && count > 0) {
Time.seconds(0.1).sleep
count -= 1
}
if (!process_result.is_finished) terminate_process()
}
/** process streams **/
/* command input */
private var command_input: Option[Consumer_Thread[List[Bytes]]] = None
private def command_input_close(): Unit = command_input.foreach(_.shutdown)
- private def command_input_init(raw_stream: OutputStream)
+ private def command_input_init(raw_stream: OutputStream): Unit =
{
val name = "command_input"
val stream = new BufferedOutputStream(raw_stream)
command_input =
Some(
Consumer_Thread.fork(name)(
consume =
{
case chunks =>
try {
Bytes(chunks.map(_.length).mkString("", ",", "\n")).write_stream(stream)
chunks.foreach(_.write_stream(stream))
stream.flush
true
}
catch { case e: IOException => system_output(name + ": " + e.getMessage); false }
},
finish = { case () => stream.close; system_output(name + " terminated") }
)
)
}
/* physical output */
private def physical_output(err: Boolean): Thread =
{
val (name, reader, markup) =
if (err) ("standard_error", process.stderr, Markup.STDERR)
else ("standard_output", process.stdout, Markup.STDOUT)
Isabelle_Thread.fork(name = name) {
try {
var result = new StringBuilder(100)
var finished = false
while (!finished) {
//{{{
var c = -1
var done = false
while (!done && (result.isEmpty || reader.ready)) {
c = reader.read
if (c >= 0) result.append(c.asInstanceOf[Char])
else done = true
}
if (result.nonEmpty) {
output(markup, Nil, List(XML.Text(Symbol.decode(result.toString))))
result.clear
}
else {
reader.close
finished = true
}
//}}}
}
}
catch { case e: IOException => system_output(name + ": " + e.getMessage) }
system_output(name + " terminated")
}
}
/* message output */
private def message_output(stream: InputStream): Thread =
{
class EOF extends Exception
class Protocol_Error(msg: String) extends Exception(msg)
val name = "message_output"
Isabelle_Thread.fork(name = name) {
val default_buffer = new Array[Byte](65536)
var c = -1
def read_int(): Int =
//{{{
{
var n = 0
c = stream.read
if (c == -1) throw new EOF
while (48 <= c && c <= 57) {
n = 10 * n + (c - 48)
c = stream.read
}
if (c != 10)
throw new Protocol_Error("malformed header: expected integer followed by newline")
else n
}
//}}}
def read_chunk_bytes(): (Array[Byte], Int) =
//{{{
{
val n = read_int()
val buf =
if (n <= default_buffer.length) default_buffer
else new Array[Byte](n)
var i = 0
var m = 0
do {
m = stream.read(buf, i, n - i)
if (m != -1) i += m
}
while (m != -1 && n > i)
if (i != n)
throw new Protocol_Error("bad chunk (unexpected EOF after " + i + " of " + n + " bytes)")
(buf, n)
}
//}}}
def read_chunk(): XML.Body =
{
val (buf, n) = read_chunk_bytes()
YXML.parse_body_failsafe(UTF8.decode_chars(Symbol.decode, buf, 0, n))
}
try {
do {
try {
val header = read_chunk()
header match {
case List(XML.Elem(Markup(name, props), Nil)) =>
val kind = name.intern
if (kind == Markup.PROTOCOL) {
val (buf, n) = read_chunk_bytes()
protocol_output(props, Bytes(buf, 0, n))
}
else {
val body = read_chunk()
output(kind, props, body)
}
case _ =>
read_chunk()
throw new Protocol_Error("bad header: " + header.toString)
}
}
catch { case _: EOF => }
}
while (c != -1)
}
catch {
case e: IOException => system_output("Cannot read message:\n" + e.getMessage)
case e: Protocol_Error => system_output("Malformed message:\n" + e.getMessage)
}
stream.close
system_output(name + " terminated")
}
}
/** protocol commands **/
var trace: Boolean = false
def protocol_command_raw(name: String, args: List[Bytes]): Unit =
command_input match {
case Some(thread) if thread.is_active =>
if (trace) {
val payload = (0 /: args)({ case (n, b) => n + b.length })
Output.writeln(
"protocol_command " + name + ", args = " + args.length + ", payload = " + payload)
}
thread.send(Bytes(name) :: args)
case _ => error("Inactive prover input thread for command " + quote(name))
}
- def protocol_command_args(name: String, args: List[String])
+ def protocol_command_args(name: String, args: List[String]): Unit =
{
receiver(new Prover.Input(name, args))
protocol_command_raw(name, args.map(Bytes(_)))
}
def protocol_command(name: String, args: String*): Unit =
protocol_command_args(name, args.toList)
}
diff --git a/src/Pure/PIDE/query_operation.scala b/src/Pure/PIDE/query_operation.scala
--- a/src/Pure/PIDE/query_operation.scala
+++ b/src/Pure/PIDE/query_operation.scala
@@ -1,243 +1,245 @@
/* Title: Pure/PIDE/query_operation.scala
Author: Makarius
One-shot query operations via asynchronous print functions and temporary
document overlays.
*/
package isabelle
object Query_Operation
{
object Status extends Enumeration
{
val WAITING = Value("waiting")
val RUNNING = Value("running")
val FINISHED = Value("finished")
}
object State
{
val empty: State = State()
def make(command: Command, query: List[String]): State =
State(instance = Document_ID.make().toString,
location = Some(command),
query = query,
status = Status.WAITING)
}
sealed case class State(
instance: String = Document_ID.none.toString,
location: Option[Command] = None,
query: List[String] = Nil,
update_pending: Boolean = false,
output: List[XML.Tree] = Nil,
status: Status.Value = Status.FINISHED,
exec_id: Document_ID.Exec = Document_ID.none)
}
class Query_Operation[Editor_Context](
editor: Editor[Editor_Context],
editor_context: Editor_Context,
operation_name: String,
consume_status: Query_Operation.Status.Value => Unit,
consume_output: (Document.Snapshot, Command.Results, XML.Body) => Unit)
{
private val print_function = operation_name + "_query"
/* implicit state -- owned by editor thread */
private val current_state = Synchronized(Query_Operation.State.empty)
def get_location: Option[Command] = current_state.value.location
- private def remove_overlay()
+ private def remove_overlay(): Unit =
{
val state = current_state.value
for (command <- state.location) {
editor.remove_overlay(command, print_function, state.instance :: state.query)
}
}
/* content update */
- private def content_update()
+ private def content_update(): Unit =
{
editor.require_dispatcher {}
/* snapshot */
val state0 = current_state.value
val (snapshot, command_results, results, removed) =
state0.location match {
case Some(cmd) =>
val snapshot = editor.node_snapshot(cmd.node_name)
val command_results = snapshot.command_results(cmd)
val results =
(for {
(_, elem @ XML.Elem(Markup(Markup.RESULT, props), _)) <- command_results.iterator
if props.contains((Markup.INSTANCE, state0.instance))
} yield elem).toList
val removed = !snapshot.get_node(cmd.node_name).commands.contains(cmd)
(snapshot, command_results, results, removed)
case None =>
(Document.Snapshot.init, Command.Results.empty, Nil, true)
}
/* resolve sendback: static command id */
def resolve_sendback(body: XML.Body): XML.Body =
{
state0.location match {
case None => body
case Some(command) =>
def resolve(body: XML.Body): XML.Body =
body map {
case XML.Wrapped_Elem(m, b1, b2) => XML.Wrapped_Elem(m, resolve(b1), resolve(b2))
case XML.Elem(Markup(Markup.SENDBACK, props), b) =>
val props1 =
props.map({
case (Markup.ID, Value.Long(id)) if id == state0.exec_id =>
(Markup.ID, Value.Long(command.id))
case p => p
})
XML.Elem(Markup(Markup.SENDBACK, props1), resolve(b))
case XML.Elem(m, b) => XML.Elem(m, resolve(b))
case t => t
}
resolve(body)
}
}
/* output */
val new_output =
for {
XML.Elem(_, List(XML.Elem(markup, body))) <- results
if Markup.messages.contains(markup.name)
body1 = resolve_sendback(body)
} yield XML.Elem(Markup(Markup.message(markup.name), markup.properties), body1)
/* status */
def get_status(name: String, status: Query_Operation.Status.Value)
: Option[Query_Operation.Status.Value] =
results.collectFirst({ case XML.Elem(_, List(elem: XML.Elem)) if elem.name == name => status })
val new_status =
if (removed) Query_Operation.Status.FINISHED
else
get_status(Markup.FINISHED, Query_Operation.Status.FINISHED) orElse
get_status(Markup.RUNNING, Query_Operation.Status.RUNNING) getOrElse
Query_Operation.Status.WAITING
/* state update */
if (new_status == Query_Operation.Status.RUNNING)
results.collectFirst(
{
case XML.Elem(Markup(_, Position.Id(id)), List(elem: XML.Elem))
if elem.name == Markup.RUNNING => id
}).foreach(id => current_state.change(_.copy(exec_id = id)))
if (state0.output != new_output || state0.status != new_status) {
if (snapshot.is_outdated)
current_state.change(_.copy(update_pending = true))
else {
current_state.change(_.copy(update_pending = false))
if (state0.output != new_output && !removed) {
current_state.change(_.copy(output = new_output))
consume_output(snapshot, command_results, new_output)
}
if (state0.status != new_status) {
current_state.change(_.copy(status = new_status))
consume_status(new_status)
if (new_status == Query_Operation.Status.FINISHED)
remove_overlay()
}
}
}
}
/* query operations */
def cancel_query(): Unit =
editor.require_dispatcher { editor.session.cancel_exec(current_state.value.exec_id) }
- def apply_query(query: List[String])
+ def apply_query(query: List[String]): Unit =
{
editor.require_dispatcher {}
editor.current_node_snapshot(editor_context) match {
case Some(snapshot) =>
remove_overlay()
current_state.change(_ => Query_Operation.State.empty)
consume_output(Document.Snapshot.init, Command.Results.empty, Nil)
editor.current_command(editor_context, snapshot) match {
case Some(command) =>
val state = Query_Operation.State.make(command, query)
current_state.change(_ => state)
editor.insert_overlay(command, print_function, state.instance :: query)
case None =>
}
consume_status(current_state.value.status)
editor.flush()
case None =>
}
}
- def locate_query()
+ def locate_query(): Unit =
{
editor.require_dispatcher {}
val state = current_state.value
for {
command <- state.location
snapshot = editor.node_snapshot(command.node_name)
link <- editor.hyperlink_command(true, snapshot, command.id)
} link.follow(editor_context)
}
/* main */
private val main =
Session.Consumer[Session.Commands_Changed](getClass.getName) {
case changed =>
val state = current_state.value
state.location match {
case Some(command)
if state.update_pending ||
(state.status != Query_Operation.Status.FINISHED &&
changed.commands.contains(command)) =>
editor.send_dispatcher { content_update() }
case _ =>
}
}
- def activate() {
+ def activate(): Unit =
+ {
editor.session.commands_changed += main
}
- def deactivate() {
+ def deactivate(): Unit =
+ {
editor.session.commands_changed -= main
remove_overlay()
current_state.change(_ => Query_Operation.State.empty)
consume_output(Document.Snapshot.init, Command.Results.empty, Nil)
consume_status(Query_Operation.Status.FINISHED)
}
}
diff --git a/src/Pure/PIDE/resources.scala b/src/Pure/PIDE/resources.scala
--- a/src/Pure/PIDE/resources.scala
+++ b/src/Pure/PIDE/resources.scala
@@ -1,449 +1,449 @@
/* Title: Pure/PIDE/resources.scala
Author: Makarius
Resources for theories and auxiliary files.
*/
package isabelle
import scala.util.parsing.input.Reader
import java.io.{File => JFile}
object Resources
{
def empty: Resources =
new Resources(Sessions.Structure.empty, Sessions.Structure.empty.bootstrap)
}
class Resources(
val sessions_structure: Sessions.Structure,
val session_base: Sessions.Base,
val log: Logger = No_Logger,
command_timings: List[Properties.T] = Nil)
{
resources =>
/* init session */
def init_session_yxml: String =
{
import XML.Encode._
YXML.string_of_body(
pair(list(pair(string, properties)),
pair(list(pair(string, string)),
pair(list(pair(string, string)),
pair(list(pair(string, list(string))),
pair(list(properties),
pair(list(pair(string, properties)),
pair(list(pair(string, string)), list(string))))))))(
(sessions_structure.session_positions,
(sessions_structure.dest_session_directories,
(sessions_structure.session_chapters,
(sessions_structure.bibtex_entries,
(command_timings,
(Scala.functions.map(fun => (fun.name, fun.position)),
(session_base.global_theories.toList,
session_base.loaded_theories.keys)))))))))
}
/* file formats */
def make_theory_name(name: Document.Node.Name): Option[Document.Node.Name] =
File_Format.registry.get(name).flatMap(_.make_theory_name(resources, name))
def make_theory_content(thy_name: Document.Node.Name): Option[String] =
File_Format.registry.get_theory(thy_name).flatMap(_.make_theory_content(resources, thy_name))
def is_hidden(name: Document.Node.Name): Boolean =
!name.is_theory || name.theory == Sessions.root_name || File_Format.registry.is_theory(name)
def html_document(snapshot: Document.Snapshot): Option[Presentation.HTML_Document] =
File_Format.registry.get(snapshot.node_name).flatMap(_.html_document(snapshot))
/* file-system operations */
def append(dir: String, source_path: Path): String =
(Path.explode(dir) + source_path).expand.implode
def append(node_name: Document.Node.Name, source_path: Path): String =
append(node_name.master_dir, source_path)
def file_node(file: Path, dir: String = "", theory: String = ""): Document.Node.Name =
{
val node = append(dir, file)
val master_dir = append(dir, file.dir)
Document.Node.Name(node, master_dir, theory)
}
def loaded_theory_node(theory: String): Document.Node.Name =
Document.Node.Name(theory, "", theory)
/* source files of Isabelle/ML bootstrap */
def source_file(raw_name: String): Option[String] =
{
if (Path.is_wellformed(raw_name)) {
if (Path.is_valid(raw_name)) {
def check(p: Path): Option[Path] = if (p.is_file) Some(p) else None
val path = Path.explode(raw_name)
val path1 =
if (path.is_absolute || path.is_current) check(path)
else {
check(Path.explode("~~/src/Pure") + path) orElse
(if (Isabelle_System.getenv("ML_SOURCES") == "") None
else check(Path.explode("$ML_SOURCES") + path))
}
Some(File.platform_path(path1 getOrElse path))
}
else None
}
else Some(raw_name)
}
/* theory files */
def load_commands(syntax: Outer_Syntax, name: Document.Node.Name)
: () => List[Command_Span.Span] =
{
val (is_utf8, raw_text) =
with_thy_reader(name, reader => (Scan.reader_is_utf8(reader), reader.source.toString))
() =>
{
if (syntax.has_load_commands(raw_text)) {
val text = Symbol.decode(Scan.reader_decode_utf8(is_utf8, raw_text))
syntax.parse_spans(text).filter(_.is_load_command(syntax))
}
else Nil
}
}
def loaded_files(syntax: Outer_Syntax, name: Document.Node.Name, spans: List[Command_Span.Span])
: List[Path] =
{
val dir = name.master_dir_path
for { span <- spans; file <- span.loaded_files(syntax).files }
yield (dir + Path.explode(file)).expand
}
def pure_files(syntax: Outer_Syntax): List[Path] =
{
val pure_dir = Path.explode("~~/src/Pure")
for {
(name, theory) <- Thy_Header.ml_roots
path = (pure_dir + Path.explode(name)).expand
node_name = Document.Node.Name(path.implode, path.dir.implode, theory)
file <- loaded_files(syntax, node_name, load_commands(syntax, node_name)())
} yield file
}
def theory_name(qualifier: String, theory: String): String =
if (Long_Name.is_qualified(theory) || session_base.global_theories.isDefinedAt(theory))
theory
else Long_Name.qualify(qualifier, theory)
def find_theory_node(theory: String): Option[Document.Node.Name] =
{
val thy_file = Path.basic(Long_Name.base_name(theory)).thy
val session = session_base.theory_qualifier(theory)
val dirs =
sessions_structure.get(session) match {
case Some(info) => info.dirs
case None => Nil
}
dirs.collectFirst({
case dir if (dir + thy_file).is_file => file_node(dir + thy_file, theory = theory) })
}
def import_name(qualifier: String, dir: String, s: String): Document.Node.Name =
{
val theory = theory_name(qualifier, Thy_Header.import_name(s))
def theory_node = file_node(Path.explode(s).thy, dir = dir, theory = theory)
if (!Thy_Header.is_base_name(s)) theory_node
else if (session_base.loaded_theory(theory)) loaded_theory_node(theory)
else {
find_theory_node(theory) match {
case Some(node_name) => node_name
case None => if (Long_Name.is_qualified(s)) loaded_theory_node(theory) else theory_node
}
}
}
def import_name(name: Document.Node.Name, s: String): Document.Node.Name =
import_name(session_base.theory_qualifier(name), name.master_dir, s)
def import_name(info: Sessions.Info, s: String): Document.Node.Name =
import_name(info.name, info.dir.implode, s)
def find_theory(file: JFile): Option[Document.Node.Name] =
{
for {
qualifier <- session_base.session_directories.get(File.canonical(file).getParentFile)
theory_base <- proper_string(Thy_Header.theory_name(file.getName))
theory = theory_name(qualifier, theory_base)
theory_node <- find_theory_node(theory)
if File.eq(theory_node.path.file, file)
} yield theory_node
}
def complete_import_name(context_name: Document.Node.Name, s: String): List[String] =
{
val context_session = session_base.theory_qualifier(context_name)
val context_dir =
try { Some(context_name.master_dir_path) }
catch { case ERROR(_) => None }
(for {
(session, (info, _)) <- sessions_structure.imports_graph.iterator
dir <- (if (session == context_session) context_dir.toList else info.dirs).iterator
theory <- Thy_Header.try_read_dir(dir).iterator
if Completion.completed(s)(theory)
} yield {
if (session == context_session || session_base.global_theories.isDefinedAt(theory)) theory
else Long_Name.qualify(session, theory)
}).toList.sorted
}
def with_thy_reader[A](name: Document.Node.Name, f: Reader[Char] => A): A =
{
val path = name.path
if (path.is_file) using(Scan.byte_reader(path.file))(f)
else if (name.node == name.theory)
error("Cannot load theory " + quote(name.theory))
else error ("Cannot load theory file " + path)
}
def check_thy(node_name: Document.Node.Name, reader: Reader[Char],
command: Boolean = true, strict: Boolean = true): Document.Node.Header =
{
if (node_name.is_theory && reader.source.length > 0) {
try {
val header = Thy_Header.read(node_name, reader, command = command, strict = strict)
val imports =
header.imports.map({ case (s, pos) =>
val name = import_name(node_name, s)
if (Sessions.exclude_theory(name.theory_base_name))
error("Bad theory name " + quote(name.theory_base_name) + Position.here(pos))
(name, pos)
})
Document.Node.Header(imports, header.keywords, header.abbrevs)
}
catch { case exn: Throwable => Document.Node.bad_header(Exn.message(exn)) }
}
else Document.Node.no_header
}
/* special header */
def special_header(name: Document.Node.Name): Option[Document.Node.Header] =
{
val imports =
if (name.theory == Sessions.root_name) List(import_name(name, Sessions.theory_name))
else if (Thy_Header.is_ml_root(name.theory)) List(import_name(name, Thy_Header.ML_BOOTSTRAP))
else if (Thy_Header.is_bootstrap(name.theory)) List(import_name(name, Thy_Header.PURE))
else Nil
if (imports.isEmpty) None
else Some(Document.Node.Header(imports.map((_, Position.none))))
}
/* blobs */
def undefined_blobs(nodes: Document.Nodes): List[Document.Node.Name] =
(for {
(node_name, node) <- nodes.iterator
if !session_base.loaded_theory(node_name)
cmd <- node.load_commands.iterator
name <- cmd.blobs_undefined.iterator
} yield name).toList
/* document changes */
def parse_change(
reparse_limit: Int,
previous: Document.Version,
doc_blobs: Document.Blobs,
edits: List[Document.Edit_Text],
consolidate: List[Document.Node.Name]): Session.Change =
Thy_Syntax.parse_change(resources, reparse_limit, previous, doc_blobs, edits, consolidate)
- def commit(change: Session.Change) { }
+ def commit(change: Session.Change): Unit = {}
/* theory and file dependencies */
def dependencies(
thys: List[(Document.Node.Name, Position.T)],
progress: Progress = new Progress): Dependencies[Unit] =
Dependencies.empty[Unit].require_thys((), thys, progress = progress)
def session_dependencies(info: Sessions.Info, progress: Progress = new Progress)
: Dependencies[Options] =
{
(Dependencies.empty[Options] /: info.theories)({ case (dependencies, (options, thys)) =>
dependencies.require_thys(options,
for { (thy, pos) <- thys } yield (import_name(info, thy), pos),
progress = progress)
})
}
object Dependencies
{
def empty[A]: Dependencies[A] = new Dependencies[A](Nil, Map.empty)
private def show_path(names: List[Document.Node.Name]): String =
names.map(name => quote(name.theory)).mkString(" via ")
private def cycle_msg(names: List[Document.Node.Name]): String =
"Cyclic dependency of " + show_path(names)
private def required_by(initiators: List[Document.Node.Name]): String =
if (initiators.isEmpty) ""
else "\n(required by " + show_path(initiators.reverse) + ")"
}
final class Dependencies[A] private(
rev_entries: List[Document.Node.Entry],
seen: Map[Document.Node.Name, A])
{
private def cons(entry: Document.Node.Entry): Dependencies[A] =
new Dependencies[A](entry :: rev_entries, seen)
def require_thy(adjunct: A,
thy: (Document.Node.Name, Position.T),
initiators: List[Document.Node.Name] = Nil,
progress: Progress = new Progress): Dependencies[A] =
{
val (name, pos) = thy
def message: String =
"The error(s) above occurred for theory " + quote(name.theory) +
Dependencies.required_by(initiators) + Position.here(pos)
if (seen.isDefinedAt(name)) this
else {
val dependencies1 = new Dependencies[A](rev_entries, seen + (name -> adjunct))
if (session_base.loaded_theory(name)) dependencies1
else {
try {
if (initiators.contains(name)) error(Dependencies.cycle_msg(initiators))
progress.expose_interrupt()
val header =
try {
with_thy_reader(name, check_thy(name, _, command = false)).cat_errors(message)
}
catch { case ERROR(msg) => cat_error(msg, message) }
val entry = Document.Node.Entry(name, header)
dependencies1.require_thys(adjunct, header.imports_pos,
initiators = name :: initiators, progress = progress).cons(entry)
}
catch {
case e: Throwable =>
dependencies1.cons(Document.Node.Entry(name, Document.Node.bad_header(Exn.message(e))))
}
}
}
}
def require_thys(adjunct: A,
thys: List[(Document.Node.Name, Position.T)],
progress: Progress = new Progress,
initiators: List[Document.Node.Name] = Nil): Dependencies[A] =
(this /: thys)(_.require_thy(adjunct, _, progress = progress, initiators = initiators))
def entries: List[Document.Node.Entry] = rev_entries.reverse
def theories: List[Document.Node.Name] = entries.map(_.name)
def theories_adjunct: List[(Document.Node.Name, A)] = theories.map(name => (name, seen(name)))
def errors: List[String] = entries.flatMap(_.header.errors)
def check_errors: Dependencies[A] =
errors match {
case Nil => this
case errs => error(cat_lines(errs))
}
lazy val theory_graph: Document.Node.Name.Graph[Unit] =
{
val regular = theories.toSet
val irregular =
(for {
entry <- entries.iterator
imp <- entry.header.imports
if !regular(imp)
} yield imp).toSet
Document.Node.Name.make_graph(
irregular.toList.map(name => ((name, ()), Nil)) :::
entries.map(entry => ((entry.name, ()), entry.header.imports)))
}
lazy val loaded_theories: Graph[String, Outer_Syntax] =
(session_base.loaded_theories /: entries)({ case (graph, entry) =>
val name = entry.name.theory
val imports = entry.header.imports.map(_.theory)
val graph1 = (graph /: (name :: imports))(_.default_node(_, Outer_Syntax.empty))
val graph2 = (graph1 /: imports)(_.add_edge(_, name))
val syntax0 = if (name == Thy_Header.PURE) List(Thy_Header.bootstrap_syntax) else Nil
val syntax1 = (name :: graph2.imm_preds(name).toList).map(graph2.get_node)
val syntax = Outer_Syntax.merge(syntax0 ::: syntax1) + entry.header
graph2.map_node(name, _ => syntax)
})
def get_syntax(name: Document.Node.Name): Outer_Syntax =
loaded_theories.get_node(name.theory)
def load_commands: List[(Document.Node.Name, List[Command_Span.Span])] =
theories.zip(
Par_List.map((e: () => List[Command_Span.Span]) => e(),
theories.map(name => resources.load_commands(get_syntax(name), name))))
.filter(p => p._2.nonEmpty)
def loaded_files(name: Document.Node.Name, spans: List[Command_Span.Span])
: (String, List[Path]) =
{
val theory = name.theory
val syntax = get_syntax(name)
val files1 = resources.loaded_files(syntax, name, spans)
val files2 = if (theory == Thy_Header.PURE) pure_files(syntax) else Nil
(theory, files1 ::: files2)
}
def loaded_files: List[Path] =
for {
(name, spans) <- load_commands
file <- loaded_files(name, spans)._2
} yield file
def imported_files: List[Path] =
{
val base_theories =
loaded_theories.all_preds(theories.map(_.theory)).
filter(session_base.loaded_theories.defined)
base_theories.map(theory => session_base.known_theories(theory).name.path) :::
base_theories.flatMap(session_base.known_loaded_files.withDefaultValue(Nil))
}
lazy val overall_syntax: Outer_Syntax =
Outer_Syntax.merge(loaded_theories.maximals.map(loaded_theories.get_node))
override def toString: String = entries.toString
}
}
diff --git a/src/Pure/PIDE/session.scala b/src/Pure/PIDE/session.scala
--- a/src/Pure/PIDE/session.scala
+++ b/src/Pure/PIDE/session.scala
@@ -1,776 +1,774 @@
/* Title: Pure/PIDE/session.scala
Author: Makarius
Options: :folding=explicit:
PIDE editor session, potentially with running prover process.
*/
package isabelle
import scala.collection.immutable.Queue
import scala.collection.mutable
import scala.annotation.tailrec
object Session
{
/* outlets */
object Consumer
{
def apply[A](name: String)(consume: A => Unit): Consumer[A] =
new Consumer[A](name, consume)
}
final class Consumer[-A] private(val name: String, val consume: A => Unit)
class Outlet[A](dispatcher: Consumer_Thread[() => Unit])
{
private val consumers = Synchronized[List[Consumer[A]]](Nil)
- def += (c: Consumer[A]) { consumers.change(Library.update(c)) }
- def -= (c: Consumer[A]) { consumers.change(Library.remove(c)) }
+ def += (c: Consumer[A]): Unit = consumers.change(Library.update(c))
+ def -= (c: Consumer[A]): Unit = consumers.change(Library.remove(c))
- def post(a: A)
+ def post(a: A): Unit =
{
for (c <- consumers.value.iterator) {
dispatcher.send(() =>
try { c.consume(a) }
catch {
case exn: Throwable =>
Output.error_message("Consumer failed: " + quote(c.name) + "\n" + Exn.message(exn))
})
}
}
}
/* change */
sealed case class Change(
previous: Document.Version,
syntax_changed: List[Document.Node.Name],
deps_changed: Boolean,
doc_edits: List[Document.Edit_Command],
consolidate: List[Document.Node.Name],
version: Document.Version)
case object Change_Flush
/* events */
//{{{
case class Command_Timing(props: Properties.T)
case class Theory_Timing(props: Properties.T)
case class Runtime_Statistics(props: Properties.T)
case class Task_Statistics(props: Properties.T)
case class Global_Options(options: Options)
case object Caret_Focus
case class Raw_Edits(doc_blobs: Document.Blobs, edits: List[Document.Edit_Text])
case class Dialog_Result(id: Document_ID.Generic, serial: Long, result: String)
case class Build_Theories(id: String, master_dir: Path, theories: List[(Options, List[Path])])
case class Commands_Changed(
assignment: Boolean, nodes: Set[Document.Node.Name], commands: Set[Command])
sealed abstract class Phase
{
def print: String =
this match {
case Terminated(result) => if (result.ok) "finished" else "failed"
case _ => Word.lowercase(this.toString)
}
}
case object Inactive extends Phase // stable
case object Startup extends Phase // transient
case object Ready extends Phase // metastable
case object Shutdown extends Phase // transient
case class Terminated(result: Process_Result) extends Phase // stable
//}}}
/* syslog */
private[Session] class Syslog(limit: Int)
{
private var queue = Queue.empty[XML.Elem]
private var length = 0
def += (msg: XML.Elem): Unit = synchronized {
queue = queue.enqueue(msg)
length += 1
if (length > limit) queue = queue.dequeue._2
}
def content: String = synchronized {
cat_lines(queue.iterator.map(XML.content)) +
(if (length > limit) "\n(A total of " + length + " messages...)" else "")
}
}
/* protocol handlers */
type Protocol_Function = Prover.Protocol_Output => Boolean
abstract class Protocol_Handler extends Isabelle_System.Service
{
def init(session: Session): Unit = {}
def exit(): Unit = {}
def functions: List[(String, Protocol_Function)] = Nil
def prover_options(options: Options): Options = options
}
}
class Session(_session_options: => Options, val resources: Resources) extends Document.Session
{
session =>
val cache: XML.Cache = XML.Cache.make()
def build_blobs_info(name: Document.Node.Name): Command.Blobs_Info =
Command.Blobs_Info.none
/* global flags */
@volatile var timing: Boolean = false
@volatile var verbose: Boolean = false
/* dynamic session options */
def session_options: Options = _session_options
def output_delay: Time = session_options.seconds("editor_output_delay")
def consolidate_delay: Time = session_options.seconds("editor_consolidate_delay")
def prune_delay: Time = session_options.seconds("editor_prune_delay")
def prune_size: Int = session_options.int("editor_prune_size")
def syslog_limit: Int = session_options.int("editor_syslog_limit")
def reparse_limit: Int = session_options.int("editor_reparse_limit")
/* dispatcher */
private val dispatcher =
Consumer_Thread.fork[() => Unit]("Session.dispatcher", daemon = true) { case e => e(); true }
def assert_dispatcher[A](body: => A): A =
{
assert(dispatcher.check_thread)
body
}
def require_dispatcher[A](body: => A): A =
{
require(dispatcher.check_thread, "not on dispatcher thread")
body
}
def send_dispatcher(body: => Unit): Unit =
{
if (dispatcher.check_thread) body
else dispatcher.send(() => body)
}
def send_wait_dispatcher(body: => Unit): Unit =
{
if (dispatcher.check_thread) body
else dispatcher.send_wait(() => body)
}
/* outlets */
val finished_theories = new Session.Outlet[Document.Snapshot](dispatcher)
val command_timings = new Session.Outlet[Session.Command_Timing](dispatcher)
val theory_timings = new Session.Outlet[Session.Theory_Timing](dispatcher)
val runtime_statistics = new Session.Outlet[Session.Runtime_Statistics](dispatcher)
val task_statistics = new Session.Outlet[Session.Task_Statistics](dispatcher)
val global_options = new Session.Outlet[Session.Global_Options](dispatcher)
val caret_focus = new Session.Outlet[Session.Caret_Focus.type](dispatcher)
val raw_edits = new Session.Outlet[Session.Raw_Edits](dispatcher)
val commands_changed = new Session.Outlet[Session.Commands_Changed](dispatcher)
val phase_changed = new Session.Outlet[Session.Phase](dispatcher)
val syslog_messages = new Session.Outlet[Prover.Output](dispatcher)
val raw_output_messages = new Session.Outlet[Prover.Output](dispatcher)
val trace_events = new Session.Outlet[Simplifier_Trace.Event.type](dispatcher)
val debugger_updates = new Session.Outlet[Debugger.Update.type](dispatcher)
val all_messages = new Session.Outlet[Prover.Message](dispatcher) // potential bottle-neck!
/** main protocol manager **/
/* internal messages */
private case class Start(start_prover: Prover.Receiver => Prover)
private case object Stop
private case class Get_State(promise: Promise[Document.State])
private case class Cancel_Exec(exec_id: Document_ID.Exec)
private case class Protocol_Command(name: String, args: List[String])
private case class Update_Options(options: Options)
private case object Consolidate_Execution
private case object Prune_History
/* phase */
private def post_phase(new_phase: Session.Phase): Session.Phase =
{
phase_changed.post(new_phase)
new_phase
}
private val _phase = Synchronized[Session.Phase](Session.Inactive)
private def phase_=(new_phase: Session.Phase): Unit = _phase.change(_ => post_phase(new_phase))
def phase: Session.Phase = _phase.value
def is_ready: Boolean = phase == Session.Ready
/* syslog */
private val syslog = new Session.Syslog(syslog_limit)
def syslog_content(): String = syslog.content
/* pipelined change parsing */
private case class Text_Edits(
previous: Future[Document.Version],
doc_blobs: Document.Blobs,
text_edits: List[Document.Edit_Text],
consolidate: List[Document.Node.Name],
version_result: Promise[Document.Version])
private val change_parser = Consumer_Thread.fork[Text_Edits]("change_parser", daemon = true)
{
case Text_Edits(previous, doc_blobs, text_edits, consolidate, version_result) =>
val prev = previous.get_finished
val change =
Timing.timeit("parse_change", timing) {
resources.parse_change(reparse_limit, prev, doc_blobs, text_edits, consolidate)
}
version_result.fulfill(change.version)
manager.send(change)
true
}
/* buffered changes */
private object change_buffer
{
private var assignment: Boolean = false
private var nodes: Set[Document.Node.Name] = Set.empty
private var commands: Set[Command] = Set.empty
def flush(): Unit = synchronized {
if (assignment || nodes.nonEmpty || commands.nonEmpty)
commands_changed.post(Session.Commands_Changed(assignment, nodes, commands))
if (nodes.nonEmpty) consolidation.update(nodes)
assignment = false
nodes = Set.empty
commands = Set.empty
}
private val delay_flush = Delay.first(output_delay) { flush() }
def invoke(assign: Boolean, edited_nodes: List[Document.Node.Name], cmds: List[Command]): Unit =
synchronized {
assignment |= assign
for (node <- edited_nodes) {
nodes += node
}
for (command <- cmds) {
nodes += command.node_name
command.blobs_names.foreach(nodes += _)
commands += command
}
delay_flush.invoke()
}
- def shutdown()
+ def shutdown(): Unit =
{
delay_flush.revoke()
flush()
}
}
/* postponed changes */
private object postponed_changes
{
private var postponed: List[Session.Change] = Nil
def store(change: Session.Change): Unit = synchronized { postponed ::= change }
def flush(state: Document.State): List[Session.Change] = synchronized {
val (assigned, unassigned) = postponed.partition(change => state.is_assigned(change.previous))
postponed = unassigned
assigned.reverse
}
}
/* node consolidation */
private object consolidation
{
private val delay =
Delay.first(consolidate_delay) { manager.send(Consolidate_Execution) }
private val init_state: Option[Set[Document.Node.Name]] = Some(Set.empty)
private val state = Synchronized(init_state)
- def exit()
+ def exit(): Unit =
{
delay.revoke()
state.change(_ => None)
}
- def update(new_nodes: Set[Document.Node.Name] = Set.empty)
+ def update(new_nodes: Set[Document.Node.Name] = Set.empty): Unit =
{
val active =
state.change_result(st =>
(st.isDefined, st.map(nodes => if (nodes.isEmpty) new_nodes else nodes ++ new_nodes)))
if (active) delay.invoke()
}
def flush(): Set[Document.Node.Name] =
state.change_result(st => if (st.isDefined) (st.get, init_state) else (Set.empty, None))
}
/* prover process */
private object prover
{
private val variable = Synchronized[Option[Prover]](None)
def defined: Boolean = variable.value.isDefined
def get: Prover = variable.value.get
- def set(p: Prover) { variable.change(_ => Some(p)) }
- def reset { variable.change(_ => None) }
- def await_reset() { variable.guarded_access({ case None => Some((), None) case _ => None }) }
+ def set(p: Prover): Unit = variable.change(_ => Some(p))
+ def reset: Unit = variable.change(_ => None)
+ def await_reset(): Unit = variable.guarded_access({ case None => Some((), None) case _ => None })
}
/* file formats and protocol handlers */
private lazy val file_formats: File_Format.Session =
File_Format.registry.start_session(session)
private val protocol_handlers = Protocol_Handlers.init(session)
def get_protocol_handler[C <: Session.Protocol_Handler](c: Class[C]): Option[C] =
protocol_handlers.get(c.getName) match {
case Some(h) if Library.is_subclass(h.getClass, c) => Some(h.asInstanceOf[C])
case _ => None
}
def init_protocol_handler(handler: Session.Protocol_Handler): Unit =
protocol_handlers.init(handler)
def prover_options(options: Options): Options =
protocol_handlers.prover_options(file_formats.prover_options(options))
/* debugger */
private val debugger_handler = new Debugger.Handler(this)
init_protocol_handler(debugger_handler)
def debugger: Debugger = debugger_handler.debugger
/* manager thread */
private val delay_prune =
Delay.first(prune_delay) { manager.send(Prune_History) }
private val manager: Consumer_Thread[Any] =
{
/* global state */
val global_state = Synchronized(Document.State.init)
/* raw edits */
def handle_raw_edits(
doc_blobs: Document.Blobs = Document.Blobs.empty,
edits: List[Document.Edit_Text] = Nil,
- consolidate: List[Document.Node.Name] = Nil)
+ consolidate: List[Document.Node.Name] = Nil): Unit =
//{{{
{
require(prover.defined, "prover process not defined (handle_raw_edits)")
if (edits.nonEmpty) prover.get.discontinue_execution()
val previous = global_state.value.history.tip.version
val version = Future.promise[Document.Version]
global_state.change(_.continue_history(previous, edits, version))
raw_edits.post(Session.Raw_Edits(doc_blobs, edits))
change_parser.send(Text_Edits(previous, doc_blobs, edits, consolidate, version))
}
//}}}
/* resulting changes */
- def handle_change(change: Session.Change)
+ def handle_change(change: Session.Change): Unit =
//{{{
{
require(prover.defined, "prover process not defined (handle_change)")
// define commands
{
val id_commands = new mutable.ListBuffer[Command]
- def id_command(command: Command)
+ def id_command(command: Command): Unit =
{
for {
(name, digest) <- command.blobs_defined
if !global_state.value.defined_blob(digest)
} {
change.version.nodes(name).get_blob match {
case Some(blob) =>
global_state.change(_.define_blob(digest))
prover.get.define_blob(digest, blob.bytes)
case None =>
Output.error_message("Missing blob " + quote(name.toString))
}
}
if (!global_state.value.defined_command(command.id)) {
global_state.change(_.define_command(command))
id_commands += command
}
}
for { (_, edit) <- change.doc_edits } {
edit.foreach({ case (c1, c2) => c1.foreach(id_command); c2.foreach(id_command) })
}
if (id_commands.nonEmpty) {
prover.get.define_commands_bulk(resources, id_commands.toList)
}
}
val assignment = global_state.value.the_assignment(change.previous).check_finished
global_state.change(_.define_version(change.version, assignment))
prover.get.update(change.previous.id, change.version.id, change.doc_edits, change.consolidate)
resources.commit(change)
}
//}}}
/* prover output */
- def handle_output(output: Prover.Output)
+ def handle_output(output: Prover.Output): Unit =
//{{{
{
- def bad_output()
+ def bad_output(): Unit =
{
if (verbose)
Output.warning("Ignoring bad prover output: " + output.message.toString)
}
- def change_command(f: Document.State => (Command.State, Document.State))
+ def change_command(f: Document.State => (Command.State, Document.State)): Unit =
{
try {
val st = global_state.change_result(f)
if (!st.command.span.is_theory) {
change_buffer.invoke(false, Nil, List(st.command))
}
}
catch { case _: Document.State.Fail => bad_output() }
}
output match {
case msg: Prover.Protocol_Output =>
val handled = protocol_handlers.invoke(msg)
if (!handled) {
msg.properties match {
case Protocol.Command_Timing(props, state_id, timing) if prover.defined =>
command_timings.post(Session.Command_Timing(props))
val message = XML.elem(Markup.STATUS, List(XML.Elem(Markup.Timing(timing), Nil)))
change_command(_.accumulate(state_id, cache.elem(message), cache))
case Markup.Theory_Timing(props) =>
theory_timings.post(Session.Theory_Timing(props))
case Markup.Task_Statistics(props) =>
task_statistics.post(Session.Task_Statistics(props))
case Protocol.Export(args)
if args.id.isDefined && Value.Long.unapply(args.id.get).isDefined =>
val id = Value.Long.unapply(args.id.get).get
val export = Export.make_entry("", args, msg.bytes, cache)
change_command(_.add_export(id, (args.serial, export)))
case Protocol.Loading_Theory(node_name, id) =>
val blobs_info = build_blobs_info(node_name)
try { global_state.change(_.begin_theory(node_name, id, msg.text, blobs_info)) }
catch { case _: Document.State.Fail => bad_output() }
case List(Markup.Commands_Accepted.PROPERTY) =>
msg.text match {
case Protocol.Commands_Accepted(ids) =>
ids.foreach(id =>
change_command(_.accumulate(id, Protocol.Commands_Accepted.message, cache)))
case _ => bad_output()
}
case List(Markup.Assign_Update.PROPERTY) =>
msg.text match {
case Protocol.Assign_Update(id, edited, update) =>
try {
val (edited_nodes, cmds) =
global_state.change_result(_.assign(id, edited, update))
change_buffer.invoke(true, edited_nodes, cmds)
manager.send(Session.Change_Flush)
}
catch { case _: Document.State.Fail => bad_output() }
case _ => bad_output()
}
delay_prune.invoke()
case List(Markup.Removed_Versions.PROPERTY) =>
msg.text match {
case Protocol.Removed(removed) =>
try {
global_state.change(_.removed_versions(removed))
manager.send(Session.Change_Flush)
}
catch { case _: Document.State.Fail => bad_output() }
case _ => bad_output()
}
case _ => bad_output()
}
}
case _ =>
output.properties match {
case Position.Id(state_id) =>
change_command(_.accumulate(state_id, output.message, cache))
case _ if output.is_init =>
val init_ok =
try {
Isabelle_System.make_services(classOf[Session.Protocol_Handler])
.foreach(init_protocol_handler)
true
}
catch {
case exn: Throwable =>
prover.get.protocol_command("Prover.stop", "1", Exn.message(exn))
false
}
if (init_ok) {
prover.get.options(prover_options(session_options))
prover.get.init_session(resources)
phase = Session.Ready
debugger.ready()
}
case Markup.Process_Result(result) if output.is_exit =>
if (prover.defined) protocol_handlers.exit()
for (id <- global_state.value.theories.keys) {
val snapshot = global_state.change_result(_.end_theory(id))
finished_theories.post(snapshot)
}
file_formats.stop_session
phase = Session.Terminated(result)
prover.reset
case _ =>
raw_output_messages.post(output)
}
}
}
//}}}
/* main thread */
Consumer_Thread.fork[Any]("Session.manager", daemon = true)
{
case arg: Any =>
//{{{
arg match {
case output: Prover.Output =>
if (output.is_syslog) {
syslog += output.message
syslog_messages.post(output)
}
if (output.is_stdout || output.is_stderr)
raw_output_messages.post(output)
else handle_output(output)
all_messages.post(output)
case input: Prover.Input =>
all_messages.post(input)
case Start(start_prover) if !prover.defined =>
prover.set(start_prover(manager.send(_)))
case Stop =>
consolidation.exit()
delay_prune.revoke()
if (prover.defined) {
global_state.change(_ => Document.State.init)
prover.get.terminate
}
case Get_State(promise) =>
promise.fulfill(global_state.value)
case Consolidate_Execution =>
if (prover.defined) {
val state = global_state.value
state.stable_tip_version match {
case None => consolidation.update()
case Some(version) =>
val consolidate =
consolidation.flush().iterator.filter(name =>
!resources.session_base.loaded_theory(name) &&
!state.node_consolidated(version, name) &&
state.node_maybe_consolidated(version, name)).toList
if (consolidate.nonEmpty) handle_raw_edits(consolidate = consolidate)
}
}
case Prune_History =>
if (prover.defined) {
val old_versions = global_state.change_result(_.remove_versions(prune_size))
if (old_versions.nonEmpty) prover.get.remove_versions(old_versions)
}
case Update_Options(options) =>
if (prover.defined && is_ready) {
prover.get.options(prover_options(options))
handle_raw_edits()
}
global_options.post(Session.Global_Options(options))
case Cancel_Exec(exec_id) if prover.defined =>
prover.get.cancel_exec(exec_id)
case Session.Raw_Edits(doc_blobs, edits) if prover.defined =>
handle_raw_edits(doc_blobs = doc_blobs, edits = edits)
case Session.Dialog_Result(id, serial, result) if prover.defined =>
prover.get.dialog_result(serial, result)
handle_output(new Prover.Output(Protocol.Dialog_Result(id, serial, result)))
case Protocol_Command(name, args) if prover.defined =>
prover.get.protocol_command_args(name, args)
case change: Session.Change if prover.defined =>
val state = global_state.value
if (!state.removing_versions && state.is_assigned(change.previous))
handle_change(change)
else postponed_changes.store(change)
case Session.Change_Flush if prover.defined =>
val state = global_state.value
if (!state.removing_versions)
postponed_changes.flush(state).foreach(handle_change)
case bad =>
if (verbose) Output.warning("Ignoring bad message: " + bad.toString)
}
true
//}}}
}
}
/* main operations */
def get_state(): Document.State =
{
if (manager.is_active) {
val promise = Future.promise[Document.State]
manager.send_wait(Get_State(promise))
promise.join
}
else Document.State.init
}
def snapshot(name: Document.Node.Name = Document.Node.Name.empty,
pending_edits: List[Text.Edit] = Nil): Document.Snapshot =
get_state().snapshot(name, pending_edits)
def recent_syntax(name: Document.Node.Name): Outer_Syntax =
get_state().recent_finished.version.get_finished.nodes(name).syntax getOrElse
resources.session_base.overall_syntax
@tailrec final def await_stable_snapshot(): Document.Snapshot =
{
val snapshot = this.snapshot()
if (snapshot.is_outdated) {
output_delay.sleep
await_stable_snapshot()
}
else snapshot
}
- def start(start_prover: Prover.Receiver => Prover)
+ def start(start_prover: Prover.Receiver => Prover): Unit =
{
file_formats
_phase.change(
{
case Session.Inactive =>
manager.send(Start(start_prover))
post_phase(Session.Startup)
case phase => error("Cannot start prover in phase " + quote(phase.print))
})
}
def stop(): Process_Result =
{
val was_ready =
_phase.guarded_access(
{
case Session.Startup | Session.Shutdown => None
case Session.Terminated(_) => Some((false, phase))
case Session.Inactive => Some((false, post_phase(Session.Terminated(Process_Result(0)))))
case Session.Ready => Some((true, post_phase(Session.Shutdown)))
})
if (was_ready) manager.send(Stop)
prover.await_reset()
change_parser.shutdown()
change_buffer.shutdown()
manager.shutdown()
dispatcher.shutdown()
phase match {
case Session.Terminated(result) => result
case phase => error("Bad session phase after shutdown: " + quote(phase.print))
}
}
- def protocol_command(name: String, args: String*)
- { manager.send(Protocol_Command(name, args.toList)) }
-
- def cancel_exec(exec_id: Document_ID.Exec)
- { manager.send(Cancel_Exec(exec_id)) }
+ def protocol_command(name: String, args: String*): Unit =
+ manager.send(Protocol_Command(name, args.toList))
- def update(doc_blobs: Document.Blobs, edits: List[Document.Edit_Text])
- {
- if (edits.nonEmpty) manager.send_wait(Session.Raw_Edits(doc_blobs, edits))
- }
+ def cancel_exec(exec_id: Document_ID.Exec): Unit =
+ manager.send(Cancel_Exec(exec_id))
- def update_options(options: Options)
- { manager.send_wait(Update_Options(options)) }
+ def update(doc_blobs: Document.Blobs, edits: List[Document.Edit_Text]): Unit =
+ if (edits.nonEmpty) manager.send_wait(Session.Raw_Edits(doc_blobs, edits))
- def dialog_result(id: Document_ID.Generic, serial: Long, result: String)
- { manager.send(Session.Dialog_Result(id, serial, result)) }
+ def update_options(options: Options): Unit =
+ manager.send_wait(Update_Options(options))
+
+ def dialog_result(id: Document_ID.Generic, serial: Long, result: String): Unit =
+ manager.send(Session.Dialog_Result(id, serial, result))
}
diff --git a/src/Pure/PIDE/text.scala b/src/Pure/PIDE/text.scala
--- a/src/Pure/PIDE/text.scala
+++ b/src/Pure/PIDE/text.scala
@@ -1,199 +1,199 @@
/* Title: Pure/PIDE/text.scala
Author: Fabian Immler, TU Munich
Author: Makarius
Basic operations on plain text.
*/
package isabelle
import scala.collection.mutable
import scala.util.Sorting
object Text
{
/* offset */
type Offset = Int
/* range -- with total quasi-ordering */
object Range
{
def apply(start: Offset): Range = Range(start, start)
val full: Range = apply(0, Integer.MAX_VALUE / 2)
val offside: Range = apply(-1)
object Ordering extends scala.math.Ordering[Range]
{
def compare(r1: Range, r2: Range): Int = r1 compare r2
}
}
sealed case class Range(start: Offset, stop: Offset)
{
// denotation: {start} Un {i. start < i & i < stop}
if (start > stop)
error("Bad range: [" + start.toString + ".." + stop.toString + "]")
override def toString: String = "[" + start.toString + ".." + stop.toString + "]"
def length: Offset = stop - start
def map(f: Offset => Offset): Range = Range(f(start), f(stop))
def +(i: Offset): Range = if (i == 0) this else map(_ + i)
def -(i: Offset): Range = if (i == 0) this else map(_ - i)
def is_singularity: Boolean = start == stop
def inflate_singularity: Range = if (is_singularity) Range(start, start + 1) else this
def touches(i: Offset): Boolean = start <= i && i <= stop
def contains(i: Offset): Boolean = start == i || start < i && i < stop
def contains(that: Range): Boolean = this.contains(that.start) && that.stop <= this.stop
def overlaps(that: Range): Boolean = this.contains(that.start) || that.contains(this.start)
def compare(that: Range): Int = if (overlaps(that)) 0 else this.start compare that.start
def apart(that: Range): Boolean =
(this.start max that.start) > (this.stop min that.stop)
def restrict(that: Range): Range =
Range(this.start max that.start, this.stop min that.stop)
def try_restrict(that: Range): Option[Range] =
if (this apart that) None
else Some(restrict(that))
def try_join(that: Range): Option[Range] =
if (this apart that) None
else Some(Range(this.start min that.start, this.stop max that.stop))
def substring(text: String): String = text.substring(start, stop)
def try_substring(text: String): Option[String] =
try { Some(substring(text)) }
catch { case _: IndexOutOfBoundsException => None }
}
/* perspective */
object Perspective
{
val empty: Perspective = Perspective(Nil)
def full: Perspective = Perspective(List(Range.full))
def apply(ranges: List[Range]): Perspective =
{
val result = new mutable.ListBuffer[Range]
var last: Option[Range] = None
- def ship(next: Option[Range]) { result ++= last; last = next }
+ def ship(next: Option[Range]): Unit = { result ++= last; last = next }
for (range <- ranges.sortBy(_.start))
{
last match {
case None => ship(Some(range))
case Some(last_range) =>
last_range.try_join(range) match {
case None => ship(Some(range))
case joined => last = joined
}
}
}
ship(None)
new Perspective(result.toList)
}
}
final class Perspective private(
val ranges: List[Range]) // visible text partitioning in canonical order
{
def is_empty: Boolean = ranges.isEmpty
def range: Range =
if (is_empty) Range(0)
else Range(ranges.head.start, ranges.last.stop)
override def hashCode: Int = ranges.hashCode
override def equals(that: Any): Boolean =
that match {
case other: Perspective => ranges == other.ranges
case _ => false
}
override def toString: String = ranges.toString
}
/* information associated with text range */
sealed case class Info[A](range: Range, info: A)
{
def restrict(r: Range): Info[A] = Info(range.restrict(r), info)
def try_restrict(r: Range): Option[Info[A]] = range.try_restrict(r).map(Info(_, info))
def map[B](f: A => B): Info[B] = Info(range, f(info))
}
type Markup = Info[XML.Elem]
/* editing */
object Edit
{
def insert(start: Offset, text: String): Edit = new Edit(true, start, text)
def remove(start: Offset, text: String): Edit = new Edit(false, start, text)
def inserts(start: Offset, text: String): List[Edit] =
if (text == "") Nil else List(insert(start, text))
def removes(start: Offset, text: String): List[Edit] =
if (text == "") Nil else List(remove(start, text))
def replace(start: Offset, old_text: String, new_text: String): List[Edit] =
if (old_text == new_text) Nil
else removes(start, old_text) ::: inserts(start, new_text)
}
final class Edit private(val is_insert: Boolean, val start: Offset, val text: String)
{
override def toString: String =
(if (is_insert) "Insert(" else "Remove(") + (start, text).toString + ")"
/* transform offsets */
private def transform(do_insert: Boolean, i: Offset): Offset =
if (i < start) i
else if (do_insert) i + text.length
else (i - text.length) max start
def convert(i: Offset): Offset = transform(is_insert, i)
def revert(i: Offset): Offset = transform(!is_insert, i)
/* edit strings */
private def insert(i: Offset, string: String): String =
string.substring(0, i) + text + string.substring(i)
private def remove(i: Offset, count: Offset, string: String): String =
string.substring(0, i) + string.substring(i + count)
def can_edit(string: String, shift: Offset): Boolean =
shift <= start && start < shift + string.length
def edit(string: String, shift: Offset): (Option[Edit], String) =
if (!can_edit(string, shift)) (Some(this), string)
else if (is_insert) (None, insert(start - shift, string))
else {
val i = start - shift
val count = text.length min (string.length - i)
val rest =
if (count == text.length) None
else Some(Edit.remove(start, text.substring(count)))
(rest, remove(i, count, string))
}
}
}
diff --git a/src/Pure/PIDE/xml.scala b/src/Pure/PIDE/xml.scala
--- a/src/Pure/PIDE/xml.scala
+++ b/src/Pure/PIDE/xml.scala
@@ -1,457 +1,457 @@
/* Title: Pure/PIDE/xml.scala
Author: Makarius
Untyped XML trees and basic data representation.
*/
package isabelle
object XML
{
/** XML trees **/
/* datatype representation */
type Attribute = Properties.Entry
type Attributes = Properties.T
sealed abstract class Tree { override def toString: String = string_of_tree(this) }
type Body = List[Tree]
case class Elem(markup: Markup, body: Body) extends Tree
{
private lazy val hash: Int = (markup, body).hashCode()
override def hashCode(): Int = hash
def name: String = markup.name
def update_attributes(more_attributes: Attributes): Elem =
if (more_attributes.isEmpty) this
else Elem(markup.update_properties(more_attributes), body)
def + (att: Attribute): Elem = Elem(markup + att, body)
}
case class Text(content: String) extends Tree
{
private lazy val hash: Int = content.hashCode()
override def hashCode(): Int = hash
}
def elem(markup: Markup): XML.Elem = XML.Elem(markup, Nil)
def elem(name: String, body: Body): XML.Elem = XML.Elem(Markup(name, Nil), body)
def elem(name: String): XML.Elem = XML.Elem(Markup(name, Nil), Nil)
val no_text: Text = Text("")
val newline: Text = Text("\n")
/* name space */
object Namespace
{
def apply(prefix: String, target: String): Namespace =
new Namespace(prefix, target)
}
final class Namespace private(prefix: String, target: String)
{
def apply(name: String): String = prefix + ":" + name
val attribute: XML.Attribute = ("xmlns:" + prefix, target)
override def toString: String = attribute.toString
}
/* wrapped elements */
val XML_ELEM = "xml_elem"
val XML_NAME = "xml_name"
val XML_BODY = "xml_body"
object Wrapped_Elem
{
def apply(markup: Markup, body1: Body, body2: Body): XML.Elem =
XML.Elem(Markup(XML_ELEM, (XML_NAME, markup.name) :: markup.properties),
XML.Elem(Markup(XML_BODY, Nil), body1) :: body2)
def unapply(tree: Tree): Option[(Markup, Body, Body)] =
tree match {
case
XML.Elem(Markup(XML_ELEM, (XML_NAME, name) :: props),
XML.Elem(Markup(XML_BODY, Nil), body1) :: body2) =>
Some(Markup(name, props), body1, body2)
case _ => None
}
}
object Root_Elem
{
def apply(body: Body): XML.Elem = XML.Elem(Markup(XML_ELEM, Nil), body)
def unapply(tree: Tree): Option[Body] =
tree match {
case XML.Elem(Markup(XML_ELEM, Nil), body) => Some(body)
case _ => None
}
}
/* traverse text */
def traverse_text[A](body: Body)(a: A)(op: (A, String) => A): A =
{
def traverse(x: A, t: Tree): A =
t match {
case XML.Wrapped_Elem(_, _, ts) => (x /: ts)(traverse)
case XML.Elem(_, ts) => (x /: ts)(traverse)
case XML.Text(s) => op(x, s)
}
(a /: body)(traverse)
}
def text_length(body: Body): Int = traverse_text(body)(0) { case (n, s) => n + s.length }
/* text content */
def content(body: Body): String =
{
val text = new StringBuilder(text_length(body))
traverse_text(body)(()) { case (_, s) => text.append(s) }
text.toString
}
def content(tree: Tree): String = content(List(tree))
/** string representation **/
val header: String = "\n"
- def output_char(s: StringBuilder, c: Char, permissive: Boolean = false)
+ def output_char(s: StringBuilder, c: Char, permissive: Boolean = false): Unit =
{
c match {
case '<' => s ++= "<"
case '>' => s ++= ">"
case '&' => s ++= "&"
case '"' if !permissive => s ++= """
case '\'' if !permissive => s ++= "'"
case _ => s += c
}
}
- def output_string(s: StringBuilder, str: String, permissive: Boolean = false)
+ def output_string(s: StringBuilder, str: String, permissive: Boolean = false): Unit =
{
if (str == null) s ++= str
else str.iterator.foreach(output_char(s, _, permissive = permissive))
}
- def output_elem(s: StringBuilder, markup: Markup, end: Boolean = false)
+ def output_elem(s: StringBuilder, markup: Markup, end: Boolean = false): Unit =
{
s += '<'
s ++= markup.name
for ((a, b) <- markup.properties) {
s += ' '
s ++= a
s += '='
s += '"'
output_string(s, b)
s += '"'
}
if (end) s += '/'
s += '>'
}
- def output_elem_end(s: StringBuilder, name: String)
+ def output_elem_end(s: StringBuilder, name: String): Unit =
{
s += '<'
s += '/'
s ++= name
s += '>'
}
def string_of_body(body: Body): String =
{
val s = new StringBuilder
def tree(t: Tree): Unit =
t match {
case XML.Elem(markup, Nil) =>
output_elem(s, markup, end = true)
case XML.Elem(markup, ts) =>
output_elem(s, markup)
ts.foreach(tree)
output_elem_end(s, markup.name)
case XML.Text(txt) => output_string(s, txt)
}
body.foreach(tree)
s.toString
}
def string_of_tree(tree: XML.Tree): String = string_of_body(List(tree))
/** cache **/
object Cache
{
def make(
xz: XZ.Cache = XZ.Cache.make(),
max_string: Int = isabelle.Cache.default_max_string,
initial_size: Int = isabelle.Cache.default_initial_size): Cache =
new Cache(xz, max_string, initial_size)
val none: Cache = make(XZ.Cache.none, max_string = 0)
}
class Cache private[XML](val xz: XZ.Cache, max_string: Int, initial_size: Int)
extends isabelle.Cache(max_string, initial_size)
{
protected def cache_props(x: Properties.T): Properties.T =
{
if (x.isEmpty) x
else
lookup(x) match {
case Some(y) => y
case None => store(x.map(p => (Library.isolate_substring(p._1).intern, cache_string(p._2))))
}
}
protected def cache_markup(x: Markup): Markup =
{
lookup(x) match {
case Some(y) => y
case None =>
x match {
case Markup(name, props) =>
store(Markup(cache_string(name), cache_props(props)))
}
}
}
protected def cache_tree(x: XML.Tree): XML.Tree =
{
lookup(x) match {
case Some(y) => y
case None =>
x match {
case XML.Elem(markup, body) =>
store(XML.Elem(cache_markup(markup), cache_body(body)))
case XML.Text(text) => store(XML.Text(cache_string(text)))
}
}
}
protected def cache_body(x: XML.Body): XML.Body =
{
if (x.isEmpty) x
else
lookup(x) match {
case Some(y) => y
case None => x.map(cache_tree)
}
}
// support hash-consing
def tree0(x: XML.Tree): XML.Tree =
if (no_cache) x else synchronized { lookup(x) getOrElse store(x) }
// main methods
def props(x: Properties.T): Properties.T =
if (no_cache) x else synchronized { cache_props(x) }
def markup(x: Markup): Markup =
if (no_cache) x else synchronized { cache_markup(x) }
def tree(x: XML.Tree): XML.Tree =
if (no_cache) x else synchronized { cache_tree(x) }
def body(x: XML.Body): XML.Body =
if (no_cache) x else synchronized { cache_body(x) }
def elem(x: XML.Elem): XML.Elem =
if (no_cache) x else synchronized { cache_tree(x).asInstanceOf[XML.Elem] }
}
/** XML as data representation language **/
abstract class Error(s: String) extends Exception(s)
class XML_Atom(s: String) extends Error(s)
class XML_Body(body: XML.Body) extends Error("")
object Encode
{
type T[A] = A => XML.Body
type V[A] = PartialFunction[A, (List[String], XML.Body)]
type P[A] = PartialFunction[A, List[String]]
/* atomic values */
def long_atom(i: Long): String = Library.signed_string_of_long(i)
def int_atom(i: Int): String = Library.signed_string_of_int(i)
def bool_atom(b: Boolean): String = if (b) "1" else "0"
def unit_atom(u: Unit) = ""
/* structural nodes */
private def node(ts: XML.Body): XML.Tree = XML.Elem(Markup(":", Nil), ts)
private def vector(xs: List[String]): XML.Attributes =
xs.zipWithIndex.map({ case (x, i) => (int_atom(i), x) })
private def tagged(tag: Int, data: (List[String], XML.Body)): XML.Tree =
XML.Elem(Markup(int_atom(tag), vector(data._1)), data._2)
/* representation of standard types */
val tree: T[XML.Tree] = (t => List(t))
val properties: T[Properties.T] =
(props => List(XML.Elem(Markup(":", props), Nil)))
val string: T[String] = (s => if (s.isEmpty) Nil else List(XML.Text(s)))
val long: T[Long] = (x => string(long_atom(x)))
val int: T[Int] = (x => string(int_atom(x)))
val bool: T[Boolean] = (x => string(bool_atom(x)))
val unit: T[Unit] = (x => string(unit_atom(x)))
def pair[A, B](f: T[A], g: T[B]): T[(A, B)] =
(x => List(node(f(x._1)), node(g(x._2))))
def triple[A, B, C](f: T[A], g: T[B], h: T[C]): T[(A, B, C)] =
(x => List(node(f(x._1)), node(g(x._2)), node(h(x._3))))
def list[A](f: T[A]): T[List[A]] =
(xs => xs.map((x: A) => node(f(x))))
def option[A](f: T[A]): T[Option[A]] =
{
case None => Nil
case Some(x) => List(node(f(x)))
}
def variant[A](fs: List[V[A]]): T[A] =
{
case x =>
val (f, tag) = fs.iterator.zipWithIndex.find(p => p._1.isDefinedAt(x)).get
List(tagged(tag, f(x)))
}
}
object Decode
{
type T[A] = XML.Body => A
type V[A] = (List[String], XML.Body) => A
type P[A] = PartialFunction[List[String], A]
/* atomic values */
def long_atom(s: String): Long =
try { java.lang.Long.parseLong(s) }
catch { case e: NumberFormatException => throw new XML_Atom(s) }
def int_atom(s: String): Int =
try { Integer.parseInt(s) }
catch { case e: NumberFormatException => throw new XML_Atom(s) }
def bool_atom(s: String): Boolean =
if (s == "1") true
else if (s == "0") false
else throw new XML_Atom(s)
def unit_atom(s: String): Unit =
if (s == "") () else throw new XML_Atom(s)
/* structural nodes */
private def node(t: XML.Tree): XML.Body =
t match {
case XML.Elem(Markup(":", Nil), ts) => ts
case _ => throw new XML_Body(List(t))
}
private def vector(atts: XML.Attributes): List[String] =
atts.iterator.zipWithIndex.map(
{ case ((a, x), i) => if (int_atom(a) == i) x else throw new XML_Atom(a) }).toList
private def tagged(t: XML.Tree): (Int, (List[String], XML.Body)) =
t match {
case XML.Elem(Markup(name, atts), ts) => (int_atom(name), (vector(atts), ts))
case _ => throw new XML_Body(List(t))
}
/* representation of standard types */
val tree: T[XML.Tree] =
{
case List(t) => t
case ts => throw new XML_Body(ts)
}
val properties: T[Properties.T] =
{
case List(XML.Elem(Markup(":", props), Nil)) => props
case ts => throw new XML_Body(ts)
}
val string: T[String] =
{
case Nil => ""
case List(XML.Text(s)) => s
case ts => throw new XML_Body(ts)
}
val long: T[Long] = (x => long_atom(string(x)))
val int: T[Int] = (x => int_atom(string(x)))
val bool: T[Boolean] = (x => bool_atom(string(x)))
val unit: T[Unit] = (x => unit_atom(string(x)))
def pair[A, B](f: T[A], g: T[B]): T[(A, B)] =
{
case List(t1, t2) => (f(node(t1)), g(node(t2)))
case ts => throw new XML_Body(ts)
}
def triple[A, B, C](f: T[A], g: T[B], h: T[C]): T[(A, B, C)] =
{
case List(t1, t2, t3) => (f(node(t1)), g(node(t2)), h(node(t3)))
case ts => throw new XML_Body(ts)
}
def list[A](f: T[A]): T[List[A]] =
(ts => ts.map(t => f(node(t))))
def option[A](f: T[A]): T[Option[A]] =
{
case Nil => None
case List(t) => Some(f(node(t)))
case ts => throw new XML_Body(ts)
}
def variant[A](fs: List[V[A]]): T[A] =
{
case List(t) =>
val (tag, (xs, ts)) = tagged(t)
val f =
try { fs(tag) }
catch { case _: IndexOutOfBoundsException => throw new XML_Body(List(t)) }
f(xs, ts)
case ts => throw new XML_Body(ts)
}
}
}
diff --git a/src/Pure/PIDE/yxml.scala b/src/Pure/PIDE/yxml.scala
--- a/src/Pure/PIDE/yxml.scala
+++ b/src/Pure/PIDE/yxml.scala
@@ -1,156 +1,150 @@
/* Title: Pure/PIDE/yxml.scala
Author: Makarius
Efficient text representation of XML trees. Suitable for direct
inlining into plain text.
*/
package isabelle
import scala.collection.mutable
object YXML
{
/* chunk markers */
val X = '\u0005'
val Y = '\u0006'
val is_X: Char => Boolean = _ == X
val is_Y: Char => Boolean = _ == Y
val X_string: String = X.toString
val Y_string: String = Y.toString
val XY_string: String = X_string + Y_string
val XYX_string: String = XY_string + X_string
def detect(s: String): Boolean = s.exists(c => c == X || c == Y)
def detect_elem(s: String): Boolean = s.startsWith(XY_string)
/* string representation */
- def traversal(string: String => Unit, body: XML.Body)
+ def traversal(string: String => Unit, body: XML.Body): Unit =
{
def tree(t: XML.Tree): Unit =
t match {
case XML.Elem(Markup(name, atts), ts) =>
string(XY_string)
string(name)
for ((a, x) <- atts) { string(Y_string); string(a); string("="); string(x) }
string(X_string)
ts.foreach(tree)
string(XYX_string)
case XML.Text(text) => string(text)
}
body.foreach(tree)
}
def string_of_body(body: XML.Body): String =
{
val s = new StringBuilder
traversal(str => s ++= str, body)
s.toString
}
def string_of_tree(tree: XML.Tree): String = string_of_body(List(tree))
/* parsing */
private def err(msg: String) = error("Malformed YXML: " + msg)
private def err_attribute() = err("bad attribute")
private def err_element() = err("bad element")
private def err_unbalanced(name: String) =
if (name == "") err("unbalanced element")
else err("unbalanced element " + quote(name))
private def parse_attrib(source: CharSequence): (String, String) =
{
val s = source.toString
val i = s.indexOf('=')
if (i <= 0) err_attribute()
(s.substring(0, i), s.substring(i + 1))
}
def parse_body(source: CharSequence, cache: XML.Cache = XML.Cache.none): XML.Body =
{
/* stack operations */
def buffer(): mutable.ListBuffer[XML.Tree] = new mutable.ListBuffer[XML.Tree]
var stack: List[(Markup, mutable.ListBuffer[XML.Tree])] = List((Markup.Empty, buffer()))
- def add(x: XML.Tree)
- {
+ def add(x: XML.Tree): Unit =
(stack: @unchecked) match { case (_, body) :: _ => body += x }
- }
- def push(name: String, atts: XML.Attributes)
- {
+ def push(name: String, atts: XML.Attributes): Unit =
if (name == "") err_element()
else stack = (cache.markup(Markup(name, atts)), buffer()) :: stack
- }
- def pop()
- {
+ def pop(): Unit =
(stack: @unchecked) match {
case (Markup.Empty, _) :: _ => err_unbalanced("")
case (markup, body) :: pending =>
stack = pending
add(cache.tree0(XML.Elem(markup, body.toList)))
}
- }
/* parse chunks */
for (chunk <- Library.separated_chunks(is_X, source) if chunk.length != 0) {
if (chunk.length == 1 && chunk.charAt(0) == Y) pop()
else {
Library.separated_chunks(is_Y, chunk).toList match {
case ch :: name :: atts if ch.length == 0 =>
push(name.toString, atts.map(parse_attrib))
case txts => for (txt <- txts) add(cache.tree0(XML.Text(cache.string(txt.toString))))
}
}
}
(stack: @unchecked) match {
case List((Markup.Empty, body)) => body.toList
case (Markup(name, _), _) :: _ => err_unbalanced(name)
}
}
def parse(source: CharSequence, cache: XML.Cache = XML.Cache.none): XML.Tree =
parse_body(source, cache = cache) match {
case List(result) => result
case Nil => XML.no_text
case _ => err("multiple XML trees")
}
def parse_elem(source: CharSequence, cache: XML.Cache = XML.Cache.none): XML.Tree =
parse_body(source, cache = cache) match {
case List(elem: XML.Elem) => elem
case _ => err("single XML element expected")
}
/* failsafe parsing */
private def markup_broken(source: CharSequence) =
XML.Elem(Markup.Broken, List(XML.Text(source.toString)))
def parse_body_failsafe(source: CharSequence, cache: XML.Cache = XML.Cache.none): XML.Body =
{
try { parse_body(source, cache = cache) }
catch { case ERROR(_) => List(markup_broken(source)) }
}
def parse_failsafe(source: CharSequence, cache: XML.Cache = XML.Cache.none): XML.Tree =
{
try { parse(source, cache = cache) }
catch { case ERROR(_) => markup_broken(source) }
}
}
diff --git a/src/Pure/System/bash.scala b/src/Pure/System/bash.scala
--- a/src/Pure/System/bash.scala
+++ b/src/Pure/System/bash.scala
@@ -1,235 +1,235 @@
/* Title: Pure/System/bash.scala
Author: Makarius
GNU bash processes, with propagation of interrupts.
*/
package isabelle
import java.io.{File => JFile, BufferedReader, InputStreamReader,
BufferedWriter, OutputStreamWriter}
import scala.annotation.tailrec
object Bash
{
/* concrete syntax */
private def bash_chr(c: Byte): String =
{
val ch = c.toChar
ch match {
case '\t' => "$'\\t'"
case '\n' => "$'\\n'"
case '\f' => "$'\\f'"
case '\r' => "$'\\r'"
case _ =>
if (Symbol.is_ascii_letter(ch) || Symbol.is_ascii_digit(ch) || "+,-./:_".contains(ch))
Symbol.ascii(ch)
else if (c < 0) "$'\\x" + Integer.toHexString(256 + c) + "'"
else if (c < 16) "$'\\x0" + Integer.toHexString(c) + "'"
else if (c < 32 || c >= 127) "$'\\x" + Integer.toHexString(c) + "'"
else "\\" + ch
}
}
def string(s: String): String =
if (s == "") "\"\""
else UTF8.bytes(s).iterator.map(bash_chr).mkString
def strings(ss: List[String]): String =
ss.iterator.map(Bash.string).mkString(" ")
/* process and result */
type Watchdog = (Time, Process => Boolean)
def process(script: String,
cwd: JFile = null,
env: Map[String, String] = Isabelle_System.settings(),
redirect: Boolean = false,
cleanup: () => Unit = () => ()): Process =
new Process(script, cwd, env, redirect, cleanup)
class Process private[Bash](
script: String,
cwd: JFile,
env: Map[String, String],
redirect: Boolean,
cleanup: () => Unit)
{
private val timing_file = Isabelle_System.tmp_file("bash_timing")
private val timing = Synchronized[Option[Timing]](None)
def get_timing: Timing = timing.value getOrElse Timing.zero
private val script_file = Isabelle_System.tmp_file("bash_script")
File.write(script_file, script)
private val proc =
Isabelle_System.process(
List(File.platform_path(Path.variable("ISABELLE_BASH_PROCESS")), "-",
File.standard_path(timing_file), "bash", File.standard_path(script_file)),
cwd = cwd, env = env, redirect = redirect)
// channels
val stdin: BufferedWriter =
new BufferedWriter(new OutputStreamWriter(proc.getOutputStream, UTF8.charset))
val stdout: BufferedReader =
new BufferedReader(new InputStreamReader(proc.getInputStream, UTF8.charset))
val stderr: BufferedReader =
new BufferedReader(new InputStreamReader(proc.getErrorStream, UTF8.charset))
// signals
private val pid = stdout.readLine
@tailrec private def kill(signal: String, count: Int = 1): Boolean =
{
count <= 0 ||
{
Isabelle_System.kill(signal, pid)
val running = Isabelle_System.kill("0", pid)._2 == 0
if (running) {
Time.seconds(0.1).sleep
kill(signal, count - 1)
}
else false
}
}
def terminate(): Unit = Isabelle_Thread.try_uninterruptible
{
kill("INT", count = 7) && kill("TERM", count = 3) && kill("KILL")
proc.destroy
do_cleanup()
}
def interrupt(): Unit = Isabelle_Thread.try_uninterruptible
{
Isabelle_System.kill("INT", pid)
}
// JVM shutdown hook
private val shutdown_hook = Isabelle_Thread.create(() => terminate())
try { Runtime.getRuntime.addShutdownHook(shutdown_hook) }
catch { case _: IllegalStateException => }
// cleanup
- private def do_cleanup()
+ private def do_cleanup(): Unit =
{
try { Runtime.getRuntime.removeShutdownHook(shutdown_hook) }
catch { case _: IllegalStateException => }
script_file.delete
timing.change {
case None =>
if (timing_file.isFile) {
val t =
Word.explode(File.read(timing_file)) match {
case List(Value.Long(elapsed), Value.Long(cpu)) =>
Timing(Time.ms(elapsed), Time.ms(cpu), Time.zero)
case _ => Timing.zero
}
timing_file.delete
Some(t)
}
else Some(Timing.zero)
case some => some
}
cleanup()
}
// join
def join: Int =
{
val rc = proc.waitFor
do_cleanup()
rc
}
// result
def result(
progress_stdout: String => Unit = (_: String) => (),
progress_stderr: String => Unit = (_: String) => (),
watchdog: Option[Watchdog] = None,
strict: Boolean = true): Process_Result =
{
stdin.close
val out_lines =
Future.thread("bash_stdout") { File.read_lines(stdout, progress_stdout) }
val err_lines =
Future.thread("bash_stderr") { File.read_lines(stderr, progress_stderr) }
val watchdog_thread =
for ((time, check) <- watchdog)
yield {
Future.thread("bash_watchdog") {
while (proc.isAlive) {
time.sleep
if (check(this)) interrupt()
}
}
}
val rc =
try { join }
catch { case Exn.Interrupt() => terminate(); Exn.Interrupt.return_code }
watchdog_thread.foreach(_.cancel)
if (strict && rc == Exn.Interrupt.return_code) throw Exn.Interrupt()
Process_Result(rc, out_lines.join, err_lines.join, get_timing)
}
}
/* Scala function */
object Process extends Scala.Fun("bash_process")
{
val here = Scala_Project.here
def apply(script: String): String =
{
val result = Exn.capture { Isabelle_System.bash(script) }
val is_interrupt =
result match {
case Exn.Res(res) => res.rc == Exn.Interrupt.return_code
case Exn.Exn(exn) => Exn.is_interrupt(exn)
}
result match {
case _ if is_interrupt => ""
case Exn.Exn(exn) => Exn.message(exn)
case Exn.Res(res) =>
Library.cat_strings0(
res.rc.toString ::
res.timing.elapsed.ms.toString ::
res.timing.cpu.ms.toString ::
res.out_lines.length.toString ::
res.out_lines ::: res.err_lines)
}
}
}
}
diff --git a/src/Pure/System/command_line.scala b/src/Pure/System/command_line.scala
--- a/src/Pure/System/command_line.scala
+++ b/src/Pure/System/command_line.scala
@@ -1,44 +1,44 @@
/* Title: Pure/System/command_line.scala
Author: Makarius
Support for Isabelle/Scala command line tools.
*/
package isabelle
object Command_Line
{
object Chunks
{
private def chunks(list: List[String]): List[List[String]] =
list.indexWhere(_ == "\n") match {
case -1 => List(list)
case i =>
val (chunk, rest) = list.splitAt(i)
chunk :: chunks(rest.tail)
}
def unapplySeq(list: List[String]): Option[List[List[String]]] = Some(chunks(list))
}
var debug = false
- def tool(body: => Unit)
+ def tool(body: => Unit): Unit =
{
val thread =
Isabelle_Thread.fork(name = "command_line", inherit_locals = true) {
val rc =
try { body; 0 }
catch {
case exn: Throwable =>
Output.error_message(Exn.message(exn) + (if (debug) "\n" + Exn.trace(exn) else ""))
Exn.return_code(exn, 2)
}
sys.exit(rc)
}
thread.join
}
def ML_tool(body: List[String]): String =
"Command_Line.tool (fn () => (" + body.mkString("; ") + "));"
}
diff --git a/src/Pure/System/cygwin.scala b/src/Pure/System/cygwin.scala
--- a/src/Pure/System/cygwin.scala
+++ b/src/Pure/System/cygwin.scala
@@ -1,68 +1,68 @@
/* Title: Pure/System/cygwin.scala
Author: Makarius
Cygwin as POSIX emulation on Windows.
*/
package isabelle
import java.io.{File => JFile}
import java.nio.file.Files
import scala.annotation.tailrec
object Cygwin
{
/* init (e.g. after extraction via 7zip) */
- def init(isabelle_root: String, cygwin_root: String)
+ def init(isabelle_root: String, cygwin_root: String): Unit =
{
require(Platform.is_windows, "Windows platform expected")
- def exec(cmdline: String*)
+ def exec(cmdline: String*): Unit =
{
val cwd = new JFile(isabelle_root)
val env = sys.env + ("CYGWIN" -> "nodosfilewarning")
val proc = Isabelle_System.process(cmdline.toList, cwd = cwd, env = env, redirect = true)
val (output, rc) = Isabelle_System.process_output(proc)
if (rc != 0) error(output)
}
val uninitialized_file = new JFile(cygwin_root, "isabelle\\uninitialized")
val uninitialized = uninitialized_file.isFile && uninitialized_file.delete
if (uninitialized) {
val symlinks =
{
val path = (new JFile(cygwin_root + "\\isabelle\\symlinks")).toPath
Files.readAllLines(path, UTF8.charset).toArray.toList.asInstanceOf[List[String]]
}
@tailrec def recover_symlinks(list: List[String]): Unit =
{
list match {
case Nil | List("") =>
case target :: content :: rest =>
link(content, new JFile(isabelle_root, target))
recover_symlinks(rest)
case _ => error("Unbalanced symlinks list")
}
}
recover_symlinks(symlinks)
exec(cygwin_root + "\\bin\\dash.exe", "/isabelle/rebaseall")
exec(cygwin_root + "\\bin\\bash.exe", "/isabelle/postinstall")
}
}
- def link(content: String, target: JFile)
+ def link(content: String, target: JFile): Unit =
{
val target_path = target.toPath
using(Files.newBufferedWriter(target_path, UTF8.charset))(
_.write("!" + content + "\u0000"))
Files.setAttribute(target_path, "dos:system", true)
}
}
diff --git a/src/Pure/System/isabelle_fonts.scala b/src/Pure/System/isabelle_fonts.scala
--- a/src/Pure/System/isabelle_fonts.scala
+++ b/src/Pure/System/isabelle_fonts.scala
@@ -1,79 +1,79 @@
/* Title: Pure/System/isabelle_system.scala
Author: Makarius
Fonts from the Isabelle system environment, notably the "Isabelle DejaVu"
collection.
*/
package isabelle
import java.awt.{Font, GraphicsEnvironment}
object Isabelle_Fonts
{
/* standard names */
val mono: String = "Isabelle DejaVu Sans Mono"
val sans: String = "Isabelle DejaVu Sans"
val serif: String = "Isabelle DejaVu Serif"
/* environment entries */
object Entry
{
object Ordering extends scala.math.Ordering[Entry]
{
def compare(entry1: Entry, entry2: Entry): Int =
entry1.family compare entry2.family match {
case 0 => entry1.style compare entry2.style
case ord => ord
}
}
}
sealed case class Entry(path: Path, hidden: Boolean = false)
{
lazy val bytes: Bytes = Bytes.read(path)
lazy val font: Font = Font.createFont(Font.TRUETYPE_FONT, path.file)
def family: String = font.getFamily
def name: String = font.getFontName
def style: Int =
(if (is_bold) Font.BOLD else 0) +
(if (is_italic) Font.ITALIC else 0)
// educated guess for style: Font.createFont always produces Font.PLAIN
private lazy val name_lowercase = Word.lowercase(name)
def is_bold: Boolean =
name_lowercase.containsSlice("bold")
def is_italic: Boolean =
name_lowercase.containsSlice("italic") ||
name_lowercase.containsSlice("oblique")
}
def make_entries(
getenv: String => String = Isabelle_System.getenv_strict(_),
hidden: Boolean = false): List[Entry] =
{
Path.split(getenv("ISABELLE_FONTS")).map(Entry(_)) :::
(if (hidden) Path.split(getenv("ISABELLE_FONTS_HIDDEN")).map(Entry(_, hidden = true)) else Nil)
}
private lazy val all_fonts: List[Entry] =
make_entries(hidden = true).sorted(Entry.Ordering)
def fonts(hidden: Boolean = false): List[Entry] =
if (hidden) all_fonts else all_fonts.filter(entry => !entry.hidden)
/* system init */
- def init()
+ def init(): Unit =
{
val ge = GraphicsEnvironment.getLocalGraphicsEnvironment()
for (entry <- fonts()) ge.registerFont(entry.font)
}
}
diff --git a/src/Pure/System/isabelle_process.scala b/src/Pure/System/isabelle_process.scala
--- a/src/Pure/System/isabelle_process.scala
+++ b/src/Pure/System/isabelle_process.scala
@@ -1,81 +1,81 @@
/* Title: Pure/System/isabelle_process.scala
Author: Makarius
Isabelle process wrapper.
*/
package isabelle
import java.io.{File => JFile}
object Isabelle_Process
{
def apply(
session: Session,
options: Options,
sessions_structure: Sessions.Structure,
store: Sessions.Store,
logic: String = "",
raw_ml_system: Boolean = false,
use_prelude: List[String] = Nil,
eval_main: String = "",
modes: List[String] = Nil,
cwd: JFile = null,
env: Map[String, String] = Isabelle_System.settings()): Isabelle_Process =
{
val channel = System_Channel()
val process =
try {
val channel_options =
options.string.update("system_channel_address", channel.address).
string.update("system_channel_password", channel.password)
ML_Process(channel_options, sessions_structure, store,
logic = logic, raw_ml_system = raw_ml_system,
use_prelude = use_prelude, eval_main = eval_main,
modes = modes, cwd = cwd, env = env)
}
catch { case exn @ ERROR(_) => channel.shutdown(); throw exn }
process.stdin.close
new Isabelle_Process(session, channel, process)
}
}
class Isabelle_Process private(session: Session, channel: System_Channel, process: Bash.Process)
{
private val startup = Future.promise[String]
private val terminated = Future.promise[Process_Result]
session.phase_changed +=
Session.Consumer(getClass.getName) {
case Session.Ready =>
startup.fulfill("")
case Session.Terminated(result) =>
if (!result.ok && !startup.is_finished) {
val syslog = session.syslog_content()
val err = "Session startup failed" + (if (syslog.isEmpty) "" else ":\n" + syslog)
startup.fulfill(err)
}
terminated.fulfill(result)
case _ =>
}
session.start(receiver => new Prover(receiver, session.cache, channel, process))
def await_startup(): Isabelle_Process =
startup.join match {
case "" => this
case err => session.stop(); error(err)
}
def await_shutdown(): Process_Result =
{
val result = terminated.join
session.stop()
result
}
- def terminate { process.terminate }
+ def terminate: Unit = process.terminate
}
diff --git a/src/Pure/System/isabelle_system.scala b/src/Pure/System/isabelle_system.scala
--- a/src/Pure/System/isabelle_system.scala
+++ b/src/Pure/System/isabelle_system.scala
@@ -1,568 +1,568 @@
/* Title: Pure/System/isabelle_system.scala
Author: Makarius
Fundamental Isabelle system environment: quasi-static module with
optional init operation.
*/
package isabelle
import java.io.{File => JFile, IOException}
import java.nio.file.{Path => JPath, Files, SimpleFileVisitor, FileVisitResult,
StandardCopyOption, FileSystemException}
import java.nio.file.attribute.BasicFileAttributes
object Isabelle_System
{
/** bootstrap information **/
def jdk_home(): String =
{
val java_home = System.getProperty("java.home", "")
val home = new JFile(java_home)
val parent = home.getParent
if (home.getName == "jre" && parent != null &&
(new JFile(new JFile(parent, "bin"), "javac")).exists) parent
else java_home
}
def bootstrap_directory(
preference: String, envar: String, property: String, description: String): String =
{
val value =
proper_string(preference) orElse // explicit argument
proper_string(System.getenv(envar)) orElse // e.g. inherited from running isabelle tool
proper_string(System.getProperty(property)) getOrElse // e.g. via JVM application boot process
error("Unknown " + description + " directory")
if ((new JFile(value)).isDirectory) value
else error("Bad " + description + " directory " + quote(value))
}
/** implicit settings environment **/
abstract class Service
@volatile private var _settings: Option[Map[String, String]] = None
@volatile private var _services: Option[List[Class[Service]]] = None
def settings(): Map[String, String] =
{
if (_settings.isEmpty) init() // unsynchronized check
_settings.get
}
def services(): List[Class[Service]] =
{
if (_services.isEmpty) init() // unsynchronized check
_services.get
}
def make_services[C](c: Class[C]): List[C] =
for { c1 <- services() if Library.is_subclass(c1, c) }
yield c1.getDeclaredConstructor().newInstance().asInstanceOf[C]
def init(isabelle_root: String = "", cygwin_root: String = ""): Unit = synchronized
{
if (_settings.isEmpty || _services.isEmpty) {
val isabelle_root1 =
bootstrap_directory(isabelle_root, "ISABELLE_ROOT", "isabelle.root", "Isabelle root")
val cygwin_root1 =
if (Platform.is_windows)
bootstrap_directory(cygwin_root, "CYGWIN_ROOT", "cygwin.root", "Cygwin root")
else ""
if (Platform.is_windows) Cygwin.init(isabelle_root1, cygwin_root1)
- def set_cygwin_root()
+ def set_cygwin_root(): Unit =
{
if (Platform.is_windows)
_settings = Some(_settings.getOrElse(Map.empty) + ("CYGWIN_ROOT" -> cygwin_root1))
}
set_cygwin_root()
def default(env: Map[String, String], entry: (String, String)): Map[String, String] =
if (env.isDefinedAt(entry._1) || entry._2 == "") env
else env + entry
val env =
{
val temp_windows =
{
val temp = if (Platform.is_windows) System.getenv("TEMP") else null
if (temp != null && temp.contains('\\')) temp else ""
}
val user_home = System.getProperty("user.home", "")
val isabelle_app = System.getProperty("isabelle.app", "")
default(
default(
default(sys.env + ("ISABELLE_JDK_HOME" -> File.standard_path(jdk_home())),
"TEMP_WINDOWS" -> temp_windows),
"HOME" -> user_home),
"ISABELLE_APP" -> "true")
}
val settings =
{
val dump = JFile.createTempFile("settings", null)
dump.deleteOnExit
try {
val cmd1 =
if (Platform.is_windows)
List(cygwin_root1 + "\\bin\\bash", "-l",
File.standard_path(isabelle_root1 + "\\bin\\isabelle"))
else
List(isabelle_root1 + "/bin/isabelle")
val cmd = cmd1 ::: List("getenv", "-d", dump.toString)
val (output, rc) = process_output(process(cmd, env = env, redirect = true))
if (rc != 0) error(output)
val entries =
(for (entry <- Library.split_strings0(File.read(dump)) if entry != "") yield {
val i = entry.indexOf('=')
if (i <= 0) entry -> ""
else entry.substring(0, i) -> entry.substring(i + 1)
}).toMap
entries + ("PATH" -> entries("PATH_JVM")) - "PATH_JVM"
}
finally { dump.delete }
}
_settings = Some(settings)
set_cygwin_root()
val variable = "ISABELLE_SCALA_SERVICES"
val services =
for (name <- space_explode(':', settings.getOrElse(variable, getenv_error(variable))))
yield {
def err(msg: String): Nothing =
error("Bad entry " + quote(name) + " in " + variable + "\n" + msg)
try { Class.forName(name).asInstanceOf[Class[Service]] }
catch {
case _: ClassNotFoundException => err("Class not found")
case exn: Throwable => err(Exn.message(exn))
}
}
_services = Some(services)
}
}
/* getenv */
private def getenv_error(name: String): Nothing =
error("Undefined Isabelle environment variable: " + quote(name))
def getenv(name: String, env: Map[String, String] = settings()): String =
env.getOrElse(name, "")
def getenv_strict(name: String, env: Map[String, String] = settings()): String =
proper_string(getenv(name, env)) getOrElse
error("Undefined Isabelle environment variable: " + quote(name))
def cygwin_root(): String = getenv_strict("CYGWIN_ROOT")
def isabelle_id(): String =
proper_string(getenv("ISABELLE_ID")) getOrElse
Mercurial.repository(Path.explode("~~")).parent()
/** file-system operations **/
/* scala functions */
private def apply_paths(arg: String, fun: List[Path] => Unit): String =
{ fun(Library.split_strings0(arg).map(Path.explode)); "" }
private def apply_paths1(arg: String, fun: Path => Unit): String =
apply_paths(arg, { case List(path) => fun(path) })
private def apply_paths2(arg: String, fun: (Path, Path) => Unit): String =
apply_paths(arg, { case List(path1, path2) => fun(path1, path2) })
private def apply_paths3(arg: String, fun: (Path, Path, Path) => Unit): String =
apply_paths(arg, { case List(path1, path2, path3) => fun(path1, path2, path3) })
/* permissions */
def chmod(arg: String, path: Path): Unit =
bash("chmod " + arg + " " + File.bash_path(path)).check
def chown(arg: String, path: Path): Unit =
bash("chown " + arg + " " + File.bash_path(path)).check
/* directories */
def make_directory(path: Path): Path =
{
if (!path.is_dir) {
try { Files.createDirectories(path.file.toPath) }
catch { case ERROR(_) => error("Failed to create directory: " + path.absolute) }
}
path
}
def new_directory(path: Path): Path =
if (path.is_dir) error("Directory already exists: " + path.absolute)
else make_directory(path)
def copy_dir(dir1: Path, dir2: Path): Unit =
{
val res = bash("cp -a " + File.bash_path(dir1) + " " + File.bash_path(dir2))
if (!res.ok) {
cat_error("Failed to copy directory " + dir1.absolute + " to " + dir2.absolute, res.err)
}
}
object Make_Directory extends Scala.Fun("make_directory")
{
val here = Scala_Project.here
def apply(arg: String): String = apply_paths1(arg, make_directory)
}
object Copy_Dir extends Scala.Fun("copy_dir")
{
val here = Scala_Project.here
def apply(arg: String): String = apply_paths2(arg, copy_dir)
}
/* copy files */
def copy_file(src: JFile, dst: JFile): Unit =
{
val target = if (dst.isDirectory) new JFile(dst, src.getName) else dst
if (!File.eq(src, target)) {
try {
Files.copy(src.toPath, target.toPath,
StandardCopyOption.COPY_ATTRIBUTES,
StandardCopyOption.REPLACE_EXISTING)
}
catch {
case ERROR(msg) =>
cat_error("Failed top copy file " +
File.path(src).absolute + " to " + File.path(dst).absolute, msg)
}
}
}
def copy_file(src: Path, dst: Path): Unit = copy_file(src.file, dst.file)
def copy_file_base(base_dir: Path, src: Path, target_dir: Path): Unit =
{
val src1 = src.expand
val src1_dir = src1.dir
if (!src1.starts_basic) error("Illegal path specification " + src1 + " beyond base directory")
copy_file(base_dir + src1, Isabelle_System.make_directory(target_dir + src1_dir))
}
object Copy_File extends Scala.Fun("copy_file")
{
val here = Scala_Project.here
def apply(arg: String): String = apply_paths2(arg, copy_file)
}
object Copy_File_Base extends Scala.Fun("copy_file_base")
{
val here = Scala_Project.here
def apply(arg: String): String = apply_paths3(arg, copy_file_base)
}
/* move files */
- def move_file(src: JFile, dst: JFile)
+ def move_file(src: JFile, dst: JFile): Unit =
{
val target = if (dst.isDirectory) new JFile(dst, src.getName) else dst
if (!File.eq(src, target))
Files.move(src.toPath, target.toPath, StandardCopyOption.REPLACE_EXISTING)
}
def move_file(src: Path, dst: Path): Unit = move_file(src.file, dst.file)
/* symbolic link */
- def symlink(src: Path, dst: Path, force: Boolean = false)
+ def symlink(src: Path, dst: Path, force: Boolean = false): Unit =
{
val src_file = src.file
val dst_file = dst.file
val target = if (dst_file.isDirectory) new JFile(dst_file, src_file.getName) else dst_file
if (force) target.delete
try { Files.createSymbolicLink(target.toPath, src_file.toPath) }
catch {
case _: UnsupportedOperationException if Platform.is_windows =>
Cygwin.link(File.standard_path(src), target)
case _: FileSystemException if Platform.is_windows =>
Cygwin.link(File.standard_path(src), target)
}
}
/* tmp files */
def isabelle_tmp_prefix(): JFile =
{
val path = Path.explode("$ISABELLE_TMP_PREFIX")
path.file.mkdirs // low-level mkdirs to avoid recursion via Isabelle environment
File.platform_file(path)
}
def tmp_file(name: String, ext: String = "", base_dir: JFile = isabelle_tmp_prefix()): JFile =
{
val suffix = if (ext == "") "" else "." + ext
val file = Files.createTempFile(base_dir.toPath, name, suffix).toFile
file.deleteOnExit
file
}
def with_tmp_file[A](name: String, ext: String = "")(body: Path => A): A =
{
val file = tmp_file(name, ext)
try { body(File.path(file)) } finally { file.delete }
}
/* tmp dirs */
def rm_tree(root: JFile): Unit =
{
root.delete
if (root.isDirectory) {
Files.walkFileTree(root.toPath,
new SimpleFileVisitor[JPath] {
override def visitFile(file: JPath, attrs: BasicFileAttributes): FileVisitResult =
{
try { Files.deleteIfExists(file) }
catch { case _: IOException => }
FileVisitResult.CONTINUE
}
override def postVisitDirectory(dir: JPath, e: IOException): FileVisitResult =
{
if (e == null) {
try { Files.deleteIfExists(dir) }
catch { case _: IOException => }
FileVisitResult.CONTINUE
}
else throw e
}
}
)
}
}
def rm_tree(root: Path): Unit = rm_tree(root.file)
object Rm_Tree extends Scala.Fun("rm_tree")
{
val here = Scala_Project.here
def apply(arg: String): String = apply_paths1(arg, rm_tree)
}
def tmp_dir(name: String, base_dir: JFile = isabelle_tmp_prefix()): JFile =
{
val dir = Files.createTempDirectory(base_dir.toPath, name).toFile
dir.deleteOnExit
dir
}
def with_tmp_dir[A](name: String)(body: Path => A): A =
{
val dir = tmp_dir(name)
try { body(File.path(dir)) } finally { rm_tree(dir) }
}
/* quasi-atomic update of directory */
- def update_directory(dir: Path, f: Path => Unit)
+ def update_directory(dir: Path, f: Path => Unit): Unit =
{
val new_dir = dir.ext("new")
val old_dir = dir.ext("old")
rm_tree(new_dir)
rm_tree(old_dir)
f(new_dir)
if (dir.is_dir) move_file(dir, old_dir)
move_file(new_dir, dir)
rm_tree(old_dir)
}
/** external processes **/
/* raw process */
def process(command_line: List[String],
cwd: JFile = null,
env: Map[String, String] = settings(),
redirect: Boolean = false): Process =
{
val proc = new ProcessBuilder
proc.command(command_line:_*) // fragile on Windows
if (cwd != null) proc.directory(cwd)
if (env != null) {
proc.environment.clear
for ((x, y) <- env) proc.environment.put(x, y)
}
proc.redirectErrorStream(redirect)
proc.start
}
def process_output(proc: Process): (String, Int) =
{
proc.getOutputStream.close
val output = File.read_stream(proc.getInputStream)
val rc =
try { proc.waitFor }
finally {
proc.getInputStream.close
proc.getErrorStream.close
proc.destroy
Exn.Interrupt.dispose()
}
(output, rc)
}
def kill(signal: String, group_pid: String): (String, Int) =
{
val bash =
if (Platform.is_windows) List(cygwin_root() + "\\bin\\bash.exe")
else List("/usr/bin/env", "bash")
process_output(process(bash ::: List("-c", "kill -" + signal + " -" + group_pid)))
}
/* GNU bash */
def bash(script: String,
cwd: JFile = null,
env: Map[String, String] = settings(),
redirect: Boolean = false,
progress_stdout: String => Unit = (_: String) => (),
progress_stderr: String => Unit = (_: String) => (),
watchdog: Option[Bash.Watchdog] = None,
strict: Boolean = true,
cleanup: () => Unit = () => ()): Process_Result =
{
Bash.process(script, cwd = cwd, env = env, redirect = redirect, cleanup = cleanup).
result(progress_stdout = progress_stdout, progress_stderr = progress_stderr,
watchdog = watchdog, strict = strict)
}
private lazy val gnutar_check: Boolean =
try { bash("tar --version").check.out.containsSlice("GNU tar") || error("") }
catch { case ERROR(_) => false }
def gnutar(
args: String,
dir: Path = Path.current,
original_owner: Boolean = false,
redirect: Boolean = false): Process_Result =
{
val options =
(if (dir.is_current) "" else "-C " + File.bash_path(dir) + " ") +
(if (original_owner) "" else "--owner=root --group=staff ")
if (gnutar_check) bash("tar " + options + args, redirect = redirect)
else error("Expected to find GNU tar executable")
}
- def require_command(cmds: String*)
+ def require_command(cmds: String*): Unit =
{
for (cmd <- cmds) {
if (!bash(Bash.string(cmd) + " --version").ok) error("Missing command: " + quote(cmd))
}
}
def hostname(): String = bash("hostname -s").check.out
def open(arg: String): Unit =
bash("exec \"$ISABELLE_OPEN\" " + Bash.string(arg) + " >/dev/null 2>/dev/null &")
def pdf_viewer(arg: Path): Unit =
bash("exec \"$PDF_VIEWER\" " + File.bash_path(arg) + " >/dev/null 2>/dev/null &")
def open_external_file(name: String): Boolean =
{
val ext = Library.take_suffix((c: Char) => c != '.', name.toList)._2.mkString
val external =
ext.nonEmpty &&
Library.space_explode(':', getenv("ISABELLE_EXTERNAL_FILES")).contains(ext)
if (external) {
if (ext == "pdf" && Path.is_wellformed(name)) pdf_viewer(Path.explode(name))
else open(name)
}
external
}
def export_isabelle_identifier(isabelle_identifier: String): String =
if (isabelle_identifier == "") ""
else "export ISABELLE_IDENTIFIER=" + Bash.string(isabelle_identifier) + "\n"
/** Isabelle resources **/
/* repository clone with Admin */
def admin(): Boolean = Path.explode("~~/Admin").is_dir
/* components */
def components(): List[Path] =
Path.split(getenv_strict("ISABELLE_COMPONENTS"))
/* default logic */
def default_logic(args: String*): String =
{
args.find(_ != "") match {
case Some(logic) => logic
case None => getenv_strict("ISABELLE_LOGIC")
}
}
/* download file */
def download(url_name: String, file: Path, progress: Progress = new Progress): Unit =
{
val url = Url(url_name)
progress.echo("Getting " + quote(url_name))
val bytes =
try { Url.read_bytes(url) }
catch { case ERROR(msg) => cat_error("Failed to download " + quote(url_name), msg) }
Bytes.write(file, bytes)
}
object Download extends Scala.Fun("download")
{
val here = Scala_Project.here
def apply(arg: String): String =
Library.split_strings0(arg) match {
case List(url, file) => download(url, Path.explode(file)); ""
}
}
}
diff --git a/src/Pure/System/isabelle_tool.scala b/src/Pure/System/isabelle_tool.scala
--- a/src/Pure/System/isabelle_tool.scala
+++ b/src/Pure/System/isabelle_tool.scala
@@ -1,228 +1,228 @@
/* Title: Pure/System/isabelle_tool.scala
Author: Makarius
Author: Lars Hupel
Isabelle system tools: external executables or internal Scala functions.
*/
package isabelle
import java.net.URLClassLoader
import scala.reflect.runtime.universe
import scala.tools.reflect.{ToolBox, ToolBoxError}
object Isabelle_Tool
{
/* Scala source tools */
abstract class Body extends Function[List[String], Unit]
private def compile(path: Path): Body =
{
def err(msg: String): Nothing =
cat_error(msg, "The error(s) above occurred in Isabelle/Scala tool " + path)
val source = File.read(path)
val class_loader = new URLClassLoader(Array(), getClass.getClassLoader)
val tool_box = universe.runtimeMirror(class_loader).mkToolBox()
try {
val symbol = tool_box.parse(source) match {
case tree: universe.ModuleDef => tool_box.define(tree)
case _ => err("Source does not describe a module (Scala object)")
}
tool_box.compile(universe.Ident(symbol))() match {
case body: Body => body
case _ => err("Ill-typed source: Isabelle_Tool.Body expected")
}
}
catch {
case e: ToolBoxError =>
if (tool_box.frontEnd.hasErrors) {
val infos = tool_box.frontEnd.infos.toList
val msgs = infos.map(info => "Error in line " + info.pos.line + ":\n" + info.msg)
err(msgs.mkString("\n"))
}
else
err(e.toString)
}
}
/* external tools */
private def dirs(): List[Path] = Path.split(Isabelle_System.getenv_strict("ISABELLE_TOOLS"))
private def is_external(dir: Path, file_name: String): Boolean =
{
val file = (dir + Path.explode(file_name)).file
try {
file.isFile && file.canRead &&
(file_name.endsWith(".scala") || file.canExecute) &&
!file_name.endsWith("~") && !file_name.endsWith(".orig")
}
catch { case _: SecurityException => false }
}
private def find_external(name: String): Option[List[String] => Unit] =
dirs().collectFirst({
case dir if is_external(dir, name + ".scala") =>
compile(dir + Path.explode(name + ".scala"))
case dir if is_external(dir, name) =>
(args: List[String]) =>
{
val tool = dir + Path.explode(name)
val result = Isabelle_System.bash(File.bash_path(tool) + " " + Bash.strings(args))
sys.exit(result.print_stdout.rc)
}
})
/* internal tools */
private lazy val internal_tools: List[Isabelle_Tool] =
Isabelle_System.make_services(classOf[Isabelle_Scala_Tools]).flatMap(_.tools)
private def find_internal(name: String): Option[List[String] => Unit] =
internal_tools.collectFirst({
case tool if tool.name == name =>
args => Command_Line.tool { tool.body(args) }
})
/* list tools */
abstract class Entry
{
def name: String
def position: Properties.T
def description: String
def print: String =
description match {
case "" => name
case descr => name + " - " + descr
}
}
sealed case class External(name: String, path: Path) extends Entry
{
def position: Properties.T = Position.File(path.absolute.implode)
def description: String =
{
val Pattern = """.*\bDESCRIPTION: *(.*)""".r
split_lines(File.read(path)).collectFirst({ case Pattern(s) => s }) getOrElse ""
}
}
def external_tools(): List[External] =
{
for {
dir <- dirs() if dir.is_dir
file_name <- File.read_dir(dir) if is_external(dir, file_name)
} yield {
val path = dir + Path.explode(file_name)
val name = Library.perhaps_unsuffix(".scala", file_name)
External(name, path)
}
}
def isabelle_tools(): List[Entry] =
(external_tools() ::: internal_tools).sortBy(_.name)
object Isabelle_Tools extends Scala.Fun("isabelle_tools")
{
val here = Scala_Project.here
def apply(arg: String): String =
if (arg.nonEmpty) error("Bad argument: " + quote(arg))
else {
val result = isabelle_tools().map(entry => (entry.name, entry.position))
val body = { import XML.Encode._; list(pair(string, properties))(result) }
YXML.string_of_body(body)
}
}
/* command line entry point */
- def main(args: Array[String])
+ def main(args: Array[String]): Unit =
{
Command_Line.tool {
args.toList match {
case Nil | List("-?") =>
val tool_descriptions = isabelle_tools().map(_.print)
Getopts("""
Usage: isabelle TOOL [ARGS ...]
Start Isabelle TOOL with ARGS; pass "-?" for tool-specific help.
Available tools:""" + tool_descriptions.mkString("\n ", "\n ", "\n")).usage
case tool_name :: tool_args =>
find_external(tool_name) orElse find_internal(tool_name) match {
case Some(tool) => tool(tool_args)
case None => error("Unknown Isabelle tool: " + quote(tool_name))
}
}
}
}
}
sealed case class Isabelle_Tool(
name: String,
description: String,
here: Scala_Project.Here,
body: List[String] => Unit) extends Isabelle_Tool.Entry
{
def position: Position.T = here.position
}
class Isabelle_Scala_Tools(val tools: Isabelle_Tool*) extends Isabelle_System.Service
class Tools extends Isabelle_Scala_Tools(
Build.isabelle_tool,
Build_Docker.isabelle_tool,
Build_Job.isabelle_tool,
Doc.isabelle_tool,
Dump.isabelle_tool,
Export.isabelle_tool,
ML_Process.isabelle_tool,
Mercurial.isabelle_tool,
Mkroot.isabelle_tool,
Options.isabelle_tool,
Phabricator.isabelle_tool1,
Phabricator.isabelle_tool2,
Phabricator.isabelle_tool3,
Phabricator.isabelle_tool4,
Presentation.isabelle_tool,
Profiling_Report.isabelle_tool,
Server.isabelle_tool,
Sessions.isabelle_tool,
Scala_Project.isabelle_tool,
Update.isabelle_tool,
Update_Cartouches.isabelle_tool,
Update_Comments.isabelle_tool,
Update_Header.isabelle_tool,
Update_Then.isabelle_tool,
Update_Theorems.isabelle_tool,
isabelle.vscode.TextMate_Grammar.isabelle_tool,
isabelle.vscode.Language_Server.isabelle_tool)
class Admin_Tools extends Isabelle_Scala_Tools(
Build_CSDP.isabelle_tool,
Build_Cygwin.isabelle_tool,
Build_Doc.isabelle_tool,
Build_E.isabelle_tool,
Build_Fonts.isabelle_tool,
Build_JDK.isabelle_tool,
Build_PolyML.isabelle_tool1,
Build_PolyML.isabelle_tool2,
Build_SPASS.isabelle_tool,
Build_SQLite.isabelle_tool,
Build_Status.isabelle_tool,
Build_Vampire.isabelle_tool,
Build_VeriT.isabelle_tool,
Build_Zipperposition.isabelle_tool,
Check_Sources.isabelle_tool,
Components.isabelle_tool,
isabelle.vscode.Build_VSCode.isabelle_tool)
diff --git a/src/Pure/System/linux.scala b/src/Pure/System/linux.scala
--- a/src/Pure/System/linux.scala
+++ b/src/Pure/System/linux.scala
@@ -1,159 +1,157 @@
/* Title: Pure/System/linux.scala
Author: Makarius
Specific support for Linux, notably Ubuntu/Debian.
*/
package isabelle
import scala.util.matching.Regex
object Linux
{
/* check system */
def check_system(): Unit =
if (!Platform.is_linux) error("Not a Linux system")
def check_system_root(): Unit =
{
check_system()
if (Isabelle_System.bash("id -u").check.out != "0") error("Not running as superuser (root)")
}
/* release */
object Release
{
private val ID = """^Distributor ID:\s*(\S.*)$""".r
private val RELEASE = """^Release:\s*(\S.*)$""".r
private val DESCRIPTION = """^Description:\s*(\S.*)$""".r
def apply(): Release =
{
val lines = Isabelle_System.bash("lsb_release -a").check.out_lines
def find(R: Regex): String = lines.collectFirst({ case R(a) => a }).getOrElse("Unknown")
new Release(find(ID), find(RELEASE), find(DESCRIPTION))
}
}
final class Release private(val id: String, val release: String, val description: String)
{
override def toString: String = description
def is_ubuntu: Boolean = id == "Ubuntu"
def is_ubuntu_18_04: Boolean = is_ubuntu && release == "18.04"
def is_ubuntu_20_04: Boolean = is_ubuntu && release == "20.04"
}
/* packages */
def reboot_required(): Boolean =
Path.explode("/var/run/reboot-required").is_file
def check_reboot_required(): Unit =
if (reboot_required()) error("Reboot required")
def package_update(progress: Progress = new Progress): Unit =
progress.bash(
"""apt-get update -y && apt-get upgrade -y && apt autoremove -y""",
echo = true).check
def package_install(packages: List[String], progress: Progress = new Progress): Unit =
progress.bash("apt-get install -y -- " + Bash.strings(packages), echo = true).check
def package_installed(name: String): Boolean =
{
val result = Isabelle_System.bash("dpkg-query -s " + Bash.string(name))
val pattern = """^Status:.*installed.*$""".r.pattern
result.ok && result.out_lines.exists(line => pattern.matcher(line).matches)
}
/* users */
def user_exists(name: String): Boolean =
Isabelle_System.bash("id " + Bash.string(name)).ok
def user_entry(name: String, field: Int): String =
{
val result = Isabelle_System.bash("getent passwd " + Bash.string(name)).check
val fields = space_explode(':', result.out)
if (1 <= field && field <= fields.length) fields(field - 1)
else error("No passwd field " + field + " for user " + quote(name))
}
def user_description(name: String): String = user_entry(name, 5).takeWhile(_ != ',')
def user_home(name: String): String = user_entry(name, 6)
def user_add(name: String,
description: String = "",
system: Boolean = false,
- ssh_setup: Boolean = false)
+ ssh_setup: Boolean = false): Unit =
{
require(!description.contains(','), "malformed description")
if (user_exists(name)) error("User already exists: " + quote(name))
Isabelle_System.bash(
"adduser --quiet --disabled-password --gecos " + Bash.string(description) +
(if (system) " --system --group --shell /bin/bash " else "") +
" " + Bash.string(name)).check
if (ssh_setup) {
val id_rsa = user_home(name) + "/.ssh/id_rsa"
Isabelle_System.bash("""
if [ ! -f """ + Bash.string(id_rsa) + """ ]
then
yes '\n' | sudo -i -u """ + Bash.string(name) +
""" ssh-keygen -q -f """ + Bash.string(id_rsa) + """
fi
""").check
}
}
/* system services */
def service_operation(op: String, name: String): Unit =
Isabelle_System.bash("systemctl " + Bash.string(op) + " " + Bash.string(name)).check
- def service_enable(name: String) { service_operation("enable", name) }
- def service_disable(name: String) { service_operation("disable", name) }
- def service_start(name: String) { service_operation("start", name) }
- def service_stop(name: String) { service_operation("stop", name) }
- def service_restart(name: String) { service_operation("restart", name) }
+ def service_enable(name: String): Unit = service_operation("enable", name)
+ def service_disable(name: String): Unit = service_operation("disable", name)
+ def service_start(name: String): Unit = service_operation("start", name)
+ def service_stop(name: String): Unit = service_operation("stop", name)
+ def service_restart(name: String): Unit = service_operation("restart", name)
- def service_shutdown(name: String)
- {
+ def service_shutdown(name: String): Unit =
try { service_stop(name) }
catch { case ERROR(_) => }
- }
- def service_install(name: String, spec: String)
+ def service_install(name: String, spec: String): Unit =
{
service_shutdown(name)
val service_file = Path.explode("/lib/systemd/system") + Path.basic(name).ext("service")
File.write(service_file, spec)
Isabelle_System.chmod("644", service_file)
service_enable(name)
service_restart(name)
}
/* passwords */
def generate_password(length: Int = 10): String =
{
require(length >= 6, "password too short")
Isabelle_System.bash("pwgen " + length + " 1").check.out
}
}
diff --git a/src/Pure/System/mingw.scala b/src/Pure/System/mingw.scala
--- a/src/Pure/System/mingw.scala
+++ b/src/Pure/System/mingw.scala
@@ -1,51 +1,51 @@
/* Title: Pure/System/mingw.scala
Author: Makarius
Support for MSYS2/MinGW64 on Windows.
*/
package isabelle
object MinGW
{
def environment: List[String] =
List("PATH=/usr/bin:/bin:/mingw64/bin", "CONFIG_SITE=/mingw64/etc/config.site")
def environment_export: String =
environment.map(a => "export " + Bash.string(a)).mkString("", "\n", "\n")
val none: MinGW = new MinGW(None)
def apply(path: Path) = new MinGW(Some(path))
}
class MinGW private(val root: Option[Path])
{
override def toString: String =
root match {
case None => "MinGW.none"
case Some(msys_root) => "MinGW(" + msys_root.toString + ")"
}
def bash_script(script: String): String =
root match {
case None => script
case Some(msys_root) =>
File.bash_path(msys_root + Path.explode("usr/bin/bash")) +
" -c " + Bash.string(MinGW.environment_export + script)
}
def get_root: Path =
if (!Platform.is_windows) error("Windows platform required")
else if (root.isEmpty) error("Windows platform requires msys/mingw root specification")
else root.get
- def check
+ def check: Unit =
{
if (Platform.is_windows) {
get_root
try { require(Isabelle_System.bash(bash_script("uname -s")).check.out.startsWith("MSYS")) }
catch { case ERROR(msg) => cat_error("Bad msys/mingw installation " + get_root, msg) }
}
}
}
diff --git a/src/Pure/System/options.scala b/src/Pure/System/options.scala
--- a/src/Pure/System/options.scala
+++ b/src/Pure/System/options.scala
@@ -1,454 +1,454 @@
/* Title: Pure/System/options.scala
Author: Makarius
System options with external string representation.
*/
package isabelle
object Options
{
type Spec = (String, Option[String])
val empty: Options = new Options()
/* representation */
sealed abstract class Type
{
def print: String = Word.lowercase(toString)
}
case object Bool extends Type
case object Int extends Type
case object Real extends Type
case object String extends Type
case object Unknown extends Type
case class Opt(
public: Boolean,
pos: Position.T,
name: String,
typ: Type,
value: String,
default_value: String,
description: String,
section: String)
{
private def print(default: Boolean): String =
{
val x = if (default) default_value else value
"option " + name + " : " + typ.print + " = " +
(if (typ == Options.String) quote(x) else x) +
(if (description == "") "" else "\n -- " + quote(description))
}
def print: String = print(false)
def print_default: String = print(true)
def title(strip: String = ""): String =
{
val words = Word.explode('_', name)
val words1 =
words match {
case word :: rest if word == strip => rest
case _ => words
}
Word.implode(words1.map(Word.perhaps_capitalize))
}
def unknown: Boolean = typ == Unknown
}
/* parsing */
private val SECTION = "section"
private val PUBLIC = "public"
private val OPTION = "option"
private val OPTIONS = Path.explode("etc/options")
private val PREFS = Path.explode("$ISABELLE_HOME_USER/etc/preferences")
val options_syntax: Outer_Syntax =
Outer_Syntax.empty + ":" + "=" + "--" + Symbol.comment + Symbol.comment_decoded +
(SECTION, Keyword.DOCUMENT_HEADING) +
(PUBLIC, Keyword.BEFORE_COMMAND) +
(OPTION, Keyword.THY_DECL)
val prefs_syntax: Outer_Syntax = Outer_Syntax.empty + "="
trait Parser extends Parse.Parser
{
val option_name: Parser[String] = atom("option name", _.is_name)
val option_type: Parser[String] = atom("option type", _.is_name)
val option_value: Parser[String] =
opt(token("-", tok => tok.is_sym_ident && tok.content == "-")) ~ atom("nat", _.is_nat) ^^
{ case s ~ n => if (s.isDefined) "-" + n else n } |
atom("option value", tok => tok.is_name || tok.is_float)
}
private object Parser extends Parser
{
def comment_marker: Parser[String] =
$$$("--") | $$$(Symbol.comment) | $$$(Symbol.comment_decoded)
val option_entry: Parser[Options => Options] =
{
command(SECTION) ~! text ^^
{ case _ ~ a => (options: Options) => options.set_section(a) } |
opt($$$(PUBLIC)) ~ command(OPTION) ~! (position(option_name) ~ $$$(":") ~ option_type ~
$$$("=") ~ option_value ~ (comment_marker ~! text ^^ { case _ ~ x => x } | success(""))) ^^
{ case a ~ _ ~ ((b, pos) ~ _ ~ c ~ _ ~ d ~ e) =>
(options: Options) => options.declare(a.isDefined, pos, b, c, d, e) }
}
val prefs_entry: Parser[Options => Options] =
{
option_name ~ ($$$("=") ~! option_value) ^^
{ case a ~ (_ ~ b) => (options: Options) => options.add_permissive(a, b) }
}
def parse_file(options: Options, file_name: String, content: String,
syntax: Outer_Syntax = options_syntax,
parser: Parser[Options => Options] = option_entry): Options =
{
val toks = Token.explode(syntax.keywords, content)
val ops =
parse_all(rep(parser), Token.reader(toks, Token.Pos.file(file_name))) match {
case Success(result, _) => result
case bad => error(bad.toString)
}
try { (options.set_section("") /: ops) { case (opts, op) => op(opts) } }
catch { case ERROR(msg) => error(msg + Position.here(Position.File(file_name))) }
}
def parse_prefs(options: Options, content: String): Options =
parse_file(options, PREFS.file_name, content, syntax = prefs_syntax, parser = prefs_entry)
}
def read_prefs(file: Path = PREFS): String =
if (file.is_file) File.read(file) else ""
def init(prefs: String = read_prefs(PREFS), opts: List[String] = Nil): Options =
{
var options = empty
for {
dir <- Isabelle_System.components()
file = dir + OPTIONS if file.is_file
} { options = Parser.parse_file(options, file.implode, File.read(file)) }
(Options.Parser.parse_prefs(options, prefs) /: opts)(_ + _)
}
/* encode */
val encode: XML.Encode.T[Options] = (options => options.encode)
/* Isabelle tool wrapper */
val isabelle_tool = Isabelle_Tool("options", "print Isabelle system options",
Scala_Project.here, args =>
{
var build_options = false
var get_option = ""
var list_options = false
var export_file = ""
val getopts = Getopts("""
Usage: isabelle options [OPTIONS] [MORE_OPTIONS ...]
Options are:
-b include $ISABELLE_BUILD_OPTIONS
-g OPTION get value of OPTION
-l list options
-x FILE export options to FILE in YXML format
Report Isabelle system options, augmented by MORE_OPTIONS given as
arguments NAME=VAL or NAME.
""",
"b" -> (_ => build_options = true),
"g:" -> (arg => get_option = arg),
"l" -> (_ => list_options = true),
"x:" -> (arg => export_file = arg))
val more_options = getopts(args)
if (get_option == "" && !list_options && export_file == "") getopts.usage()
val options =
{
val options0 = Options.init()
val options1 =
if (build_options)
(options0 /: Word.explode(Isabelle_System.getenv("ISABELLE_BUILD_OPTIONS")))(_ + _)
else options0
(options1 /: more_options)(_ + _)
}
if (get_option != "")
Output.writeln(options.check_name(get_option).value, stdout = true)
if (export_file != "")
File.write(Path.explode(export_file), YXML.string_of_body(options.encode))
if (get_option == "" && export_file == "")
Output.writeln(options.print, stdout = true)
})
}
final class Options private(
val options: Map[String, Options.Opt] = Map.empty,
val section: String = "")
{
override def toString: String = options.iterator.mkString("Options(", ",", ")")
private def print_opt(opt: Options.Opt): String =
if (opt.public) "public " + opt.print else opt.print
def print: String = cat_lines(options.toList.sortBy(_._1).map(p => print_opt(p._2)))
def description(name: String): String = check_name(name).description
/* check */
def check_name(name: String): Options.Opt =
options.get(name) match {
case Some(opt) if !opt.unknown => opt
case _ => error("Unknown option " + quote(name))
}
private def check_type(name: String, typ: Options.Type): Options.Opt =
{
val opt = check_name(name)
if (opt.typ == typ) opt
else error("Ill-typed option " + quote(name) + " : " + opt.typ.print + " vs. " + typ.print)
}
/* basic operations */
private def put[A](name: String, typ: Options.Type, value: String): Options =
{
val opt = check_type(name, typ)
new Options(options + (name -> opt.copy(value = value)), section)
}
private def get[A](name: String, typ: Options.Type, parse: String => Option[A]): A =
{
val opt = check_type(name, typ)
parse(opt.value) match {
case Some(x) => x
case None =>
error("Malformed value for option " + quote(name) +
" : " + typ.print + " =\n" + quote(opt.value))
}
}
/* internal lookup and update */
class Bool_Access
{
def apply(name: String): Boolean = get(name, Options.Bool, Value.Boolean.unapply)
def update(name: String, x: Boolean): Options =
put(name, Options.Bool, Value.Boolean(x))
}
val bool = new Bool_Access
class Int_Access
{
def apply(name: String): Int = get(name, Options.Int, Value.Int.unapply)
def update(name: String, x: Int): Options =
put(name, Options.Int, Value.Int(x))
}
val int = new Int_Access
class Real_Access
{
def apply(name: String): Double = get(name, Options.Real, Value.Double.unapply)
def update(name: String, x: Double): Options =
put(name, Options.Real, Value.Double(x))
}
val real = new Real_Access
class String_Access
{
def apply(name: String): String = get(name, Options.String, s => Some(s))
def update(name: String, x: String): Options = put(name, Options.String, x)
}
val string = new String_Access
def proper_string(name: String): Option[String] =
Library.proper_string(string(name))
def seconds(name: String): Time = Time.seconds(real(name))
/* external updates */
private def check_value(name: String): Options =
{
val opt = check_name(name)
opt.typ match {
case Options.Bool => bool(name); this
case Options.Int => int(name); this
case Options.Real => real(name); this
case Options.String => string(name); this
case Options.Unknown => this
}
}
def declare(
public: Boolean,
pos: Position.T,
name: String,
typ_name: String,
value: String,
description: String): Options =
{
options.get(name) match {
case Some(other) =>
error("Duplicate declaration of option " + quote(name) + Position.here(pos) +
Position.here(other.pos))
case None =>
val typ =
typ_name match {
case "bool" => Options.Bool
case "int" => Options.Int
case "real" => Options.Real
case "string" => Options.String
case _ =>
error("Unknown type for option " + quote(name) + " : " + quote(typ_name) +
Position.here(pos))
}
val opt = Options.Opt(public, pos, name, typ, value, value, description, section)
(new Options(options + (name -> opt), section)).check_value(name)
}
}
def add_permissive(name: String, value: String): Options =
{
if (options.isDefinedAt(name)) this + (name, value)
else {
val opt = Options.Opt(false, Position.none, name, Options.Unknown, value, value, "", "")
new Options(options + (name -> opt), section)
}
}
def + (name: String, value: String): Options =
{
val opt = check_name(name)
(new Options(options + (name -> opt.copy(value = value)), section)).check_value(name)
}
def + (name: String, opt_value: Option[String]): Options =
{
val opt = check_name(name)
opt_value match {
case Some(value) => this + (name, value)
case None if opt.typ == Options.Bool => this + (name, "true")
case None => error("Missing value for option " + quote(name) + " : " + opt.typ.print)
}
}
def + (str: String): Options =
{
str.indexOf('=') match {
case -1 => this + (str, None)
case i => this + (str.substring(0, i), str.substring(i + 1))
}
}
def ++ (specs: List[Options.Spec]): Options =
(this /: specs)({ case (x, (y, z)) => x + (y, z) })
/* sections */
def set_section(new_section: String): Options =
new Options(options, new_section)
def sections: List[(String, List[Options.Opt])] =
options.groupBy(_._2.section).toList.map({ case (a, opts) => (a, opts.toList.map(_._2)) })
/* encode */
def encode: XML.Body =
{
val opts =
for ((_, opt) <- options.toList; if !opt.unknown)
yield (opt.pos, (opt.name, (opt.typ.print, opt.value)))
import XML.Encode.{string => string_, _}
list(pair(properties, pair(string_, pair(string_, string_))))(opts)
}
/* save preferences */
- def save_prefs(file: Path = Options.PREFS)
+ def save_prefs(file: Path = Options.PREFS): Unit =
{
val defaults: Options = Options.init(prefs = "")
val changed =
(for {
(name, opt2) <- options.iterator
opt1 = defaults.options.get(name)
if opt1.isEmpty || opt1.get.value != opt2.value
} yield (name, opt2.value, if (opt1.isEmpty) " (* unknown *)" else "")).toList
val prefs =
changed.sortBy(_._1)
.map({ case (x, y, z) => x + " = " + Outer_Syntax.quote_string(y) + z + "\n" }).mkString
Isabelle_System.make_directory(file.dir)
File.write_backup(file, "(* generated by Isabelle " + Date.now() + " *)\n\n" + prefs)
}
}
class Options_Variable(init_options: Options)
{
private var options = init_options
def value: Options = synchronized { options }
private def upd(f: Options => Options): Unit = synchronized { options = f(options) }
def += (name: String, x: String): Unit = upd(opts => opts + (name, x))
class Bool_Access
{
def apply(name: String): Boolean = value.bool(name)
def update(name: String, x: Boolean): Unit = upd(opts => opts.bool.update(name, x))
}
val bool = new Bool_Access
class Int_Access
{
def apply(name: String): Int = value.int(name)
def update(name: String, x: Int): Unit = upd(opts => opts.int.update(name, x))
}
val int = new Int_Access
class Real_Access
{
def apply(name: String): Double = value.real(name)
def update(name: String, x: Double): Unit = upd(opts => opts.real.update(name, x))
}
val real = new Real_Access
class String_Access
{
def apply(name: String): String = value.string(name)
def update(name: String, x: String): Unit = upd(opts => opts.string.update(name, x))
}
val string = new String_Access
def proper_string(name: String): Option[String] =
Library.proper_string(string(name))
def seconds(name: String): Time = value.seconds(name)
}
diff --git a/src/Pure/System/posix_interrupt.scala b/src/Pure/System/posix_interrupt.scala
--- a/src/Pure/System/posix_interrupt.scala
+++ b/src/Pure/System/posix_interrupt.scala
@@ -1,29 +1,29 @@
/* Title: Pure/System/posix_interrupt.scala
Author: Makarius
Support for POSIX interrupts (bypassed on Windows).
*/
package isabelle
import sun.misc.{Signal, SignalHandler}
object POSIX_Interrupt
{
def handler[A](h: => Unit)(e: => A): A =
{
val SIGINT = new Signal("INT")
- val new_handler = new SignalHandler { def handle(s: Signal) { h } }
+ val new_handler = new SignalHandler { def handle(s: Signal): Unit = h }
val old_handler = Signal.handle(SIGINT, new_handler)
try { e } finally { Signal.handle(SIGINT, old_handler) }
}
def exception[A](e: => A): A =
{
val thread = Thread.currentThread
handler { thread.interrupt } { e }
}
}
diff --git a/src/Pure/System/progress.scala b/src/Pure/System/progress.scala
--- a/src/Pure/System/progress.scala
+++ b/src/Pure/System/progress.scala
@@ -1,87 +1,87 @@
/* Title: Pure/System/progress.scala
Author: Makarius
Progress context for system processes.
*/
package isabelle
import java.io.{File => JFile}
object Progress
{
sealed case class Theory(theory: String, session: String = "", percentage: Option[Int] = None)
{
def message: String = print_session + print_theory + print_percentage
def print_session: String = if (session == "") "" else session + ": "
def print_theory: String = "theory " + theory
def print_percentage: String =
percentage match { case None => "" case Some(p) => " " + p + "%" }
}
}
class Progress
{
- def echo(msg: String) {}
- def echo_if(cond: Boolean, msg: String) { if (cond) echo(msg) }
- def theory(theory: Progress.Theory) {}
- def nodes_status(nodes_status: Document_Status.Nodes_Status) {}
+ def echo(msg: String): Unit = {}
+ def echo_if(cond: Boolean, msg: String): Unit = { if (cond) echo(msg) }
+ def theory(theory: Progress.Theory): Unit = {}
+ def nodes_status(nodes_status: Document_Status.Nodes_Status): Unit = {}
- def echo_warning(msg: String) { echo(Output.warning_text(msg)) }
- def echo_error_message(msg: String) { echo(Output.error_message_text(msg)) }
+ def echo_warning(msg: String): Unit = echo(Output.warning_text(msg))
+ def echo_error_message(msg: String): Unit = echo(Output.error_message_text(msg))
def timeit[A](message: String = "", enabled: Boolean = true)(e: => A): A =
Timing.timeit(message, enabled, echo)(e)
@volatile protected var is_stopped = false
- def stop { is_stopped = true }
+ def stop: Unit = { is_stopped = true }
def stopped: Boolean =
{
if (Thread.interrupted) is_stopped = true
is_stopped
}
def interrupt_handler[A](e: => A): A = POSIX_Interrupt.handler { stop } { e }
- def expose_interrupt() { if (stopped) throw Exn.Interrupt() }
+ def expose_interrupt(): Unit = if (stopped) throw Exn.Interrupt()
override def toString: String = if (stopped) "Progress(stopped)" else "Progress"
def bash(script: String,
cwd: JFile = null,
env: Map[String, String] = Isabelle_System.settings(),
redirect: Boolean = false,
echo: Boolean = false,
watchdog: Time = Time.zero,
strict: Boolean = true): Process_Result =
{
val result =
Isabelle_System.bash(script, cwd = cwd, env = env, redirect = redirect,
progress_stdout = echo_if(echo, _),
progress_stderr = echo_if(echo, _),
watchdog = if (watchdog.is_zero) None else Some((watchdog, _ => stopped)),
strict = strict)
if (strict && stopped) throw Exn.Interrupt() else result
}
}
class Console_Progress(verbose: Boolean = false, stderr: Boolean = false) extends Progress
{
override def echo(msg: String): Unit =
Output.writeln(msg, stdout = !stderr, include_empty = true)
override def theory(theory: Progress.Theory): Unit =
if (verbose) echo(theory.message)
}
class File_Progress(path: Path, verbose: Boolean = false) extends Progress
{
override def echo(msg: String): Unit =
File.append(path, msg + "\n")
override def theory(theory: Progress.Theory): Unit =
if (verbose) echo(theory.message)
override def toString: String = path.toString
}
diff --git a/src/Pure/System/scala.scala b/src/Pure/System/scala.scala
--- a/src/Pure/System/scala.scala
+++ b/src/Pure/System/scala.scala
@@ -1,254 +1,254 @@
/* Title: Pure/System/scala.scala
Author: Makarius
Support for Scala at runtime.
*/
package isabelle
import java.io.{File => JFile, StringWriter, PrintWriter}
import scala.tools.nsc.{GenericRunnerSettings, ConsoleWriter, NewLinePrintWriter}
import scala.tools.nsc.interpreter.{IMain, Results}
import scala.tools.nsc.interpreter.shell.ReplReporterImpl
object Scala
{
/** registered functions **/
abstract class Fun(val name: String) extends Function[String, String]
{
override def toString: String = name
def position: Properties.T = here.position
def here: Scala_Project.Here
def apply(arg: String): String
}
class Functions(val functions: Fun*) extends Isabelle_System.Service
lazy val functions: List[Fun] =
Isabelle_System.make_services(classOf[Functions]).flatMap(_.functions)
/** demo functions **/
object Echo extends Fun("echo")
{
val here = Scala_Project.here
def apply(arg: String): String = arg
}
object Sleep extends Fun("sleep")
{
val here = Scala_Project.here
def apply(seconds: String): String =
{
val t =
seconds match {
case Value.Double(s) => Time.seconds(s)
case _ => error("Malformed argument: " + quote(seconds))
}
val t0 = Time.now()
t.sleep
val t1 = Time.now()
(t1 - t0).toString
}
}
/** compiler **/
object Compiler
{
def context(
error: String => Unit = Exn.error,
jar_dirs: List[JFile] = Nil): Context =
{
def find_jars(dir: JFile): List[String] =
File.find_files(dir, file => file.getName.endsWith(".jar")).
map(File.absolute_name)
val class_path =
for {
prop <- List("isabelle.scala.classpath", "java.class.path")
path = System.getProperty(prop, "") if path != "\"\""
elem <- space_explode(JFile.pathSeparatorChar, path)
} yield elem
val settings = new GenericRunnerSettings(error)
settings.classpath.value =
(class_path ::: jar_dirs.flatMap(find_jars)).mkString(JFile.pathSeparator)
new Context(settings)
}
def default_print_writer: PrintWriter =
new NewLinePrintWriter(new ConsoleWriter, true)
class Context private [Compiler](val settings: GenericRunnerSettings)
{
override def toString: String = settings.toString
def interpreter(
print_writer: PrintWriter = default_print_writer,
class_loader: ClassLoader = null): IMain =
{
new IMain(settings, new ReplReporterImpl(settings, print_writer))
{
override def parentClassLoader: ClassLoader =
if (class_loader == null) super.parentClassLoader
else class_loader
}
}
def toplevel(interpret: Boolean, source: String): List[String] =
{
val out = new StringWriter
val interp = interpreter(new PrintWriter(out))
val ok =
interp.withLabel("\u0001") {
if (interpret) interp.interpret(source) == Results.Success
else (new interp.ReadEvalPrint).compile(source)
}
out.close
val Error = """(?s)^\S* error: (.*)$""".r
val errors =
space_explode('\u0001', Library.strip_ansi_color(out.toString)).
collect({ case Error(msg) => "Scala error: " + Library.trim_line(msg) })
if (!ok && errors.isEmpty) List("Error") else errors
}
}
}
object Toplevel extends Fun("scala_toplevel")
{
val here = Scala_Project.here
def apply(arg: String): String =
{
val (interpret, source) =
YXML.parse_body(arg) match {
case Nil => (false, "")
case List(XML.Text(source)) => (false, source)
case body => import XML.Decode._; pair(bool, string)(body)
}
val errors =
try { Compiler.context().toplevel(interpret, source) }
catch { case ERROR(msg) => List(msg) }
locally { import XML.Encode._; YXML.string_of_body(list(string)(errors)) }
}
}
/** invoke Scala functions from ML **/
/* invoke function */
object Tag extends Enumeration
{
val NULL, OK, ERROR, FAIL, INTERRUPT = Value
}
def function(name: String, arg: String): (Tag.Value, String) =
functions.find(fun => fun.name == name) match {
case Some(fun) =>
Exn.capture { fun(arg) } match {
case Exn.Res(null) => (Tag.NULL, "")
case Exn.Res(res) => (Tag.OK, res)
case Exn.Exn(Exn.Interrupt()) => (Tag.INTERRUPT, "")
case Exn.Exn(e) => (Tag.ERROR, Exn.message(e))
}
case None => (Tag.FAIL, "Unknown Isabelle/Scala function: " + quote(name))
}
/* protocol handler */
class Handler extends Session.Protocol_Handler
{
private var session: Session = null
private var futures = Map.empty[String, Future[Unit]]
override def init(session: Session): Unit =
synchronized { this.session = session }
override def exit(): Unit = synchronized
{
for ((id, future) <- futures) cancel(id, future)
futures = Map.empty
}
private def result(id: String, tag: Scala.Tag.Value, res: String): Unit =
synchronized
{
if (futures.isDefinedAt(id)) {
session.protocol_command("Scala.result", id, tag.id.toString, res)
futures -= id
}
}
- private def cancel(id: String, future: Future[Unit])
+ private def cancel(id: String, future: Future[Unit]): Unit =
{
future.cancel
result(id, Scala.Tag.INTERRUPT, "")
}
private def invoke_scala(msg: Prover.Protocol_Output): Boolean = synchronized
{
msg.properties match {
case Markup.Invoke_Scala(name, id, thread) =>
- def body
+ def body: Unit =
{
val (tag, res) = Scala.function(name, msg.text)
result(id, tag, res)
}
val future =
if (thread) {
Future.thread(name = Isabelle_Thread.make_name(base = "invoke_scala"))(body)
}
else Future.fork(body)
futures += (id -> future)
true
case _ => false
}
}
private def cancel_scala(msg: Prover.Protocol_Output): Boolean = synchronized
{
msg.properties match {
case Markup.Cancel_Scala(id) =>
futures.get(id) match {
case Some(future) => cancel(id, future)
case None =>
}
true
case _ => false
}
}
override val functions =
List(
Markup.Invoke_Scala.name -> invoke_scala,
Markup.Cancel_Scala.name -> cancel_scala)
}
}
class Scala_Functions extends Scala.Functions(
Scala.Echo,
Scala.Sleep,
Scala.Toplevel,
Doc.Doc_Names,
Bash.Process,
Bibtex.Check_Database,
Isabelle_System.Make_Directory,
Isabelle_System.Copy_Dir,
Isabelle_System.Copy_File,
Isabelle_System.Copy_File_Base,
Isabelle_System.Rm_Tree,
Isabelle_System.Download,
Isabelle_Tool.Isabelle_Tools)
diff --git a/src/Pure/System/system_channel.scala b/src/Pure/System/system_channel.scala
--- a/src/Pure/System/system_channel.scala
+++ b/src/Pure/System/system_channel.scala
@@ -1,46 +1,46 @@
/* Title: Pure/System/system_channel.scala
Author: Makarius
Socket-based system channel for inter-process communication.
*/
package isabelle
import java.io.{InputStream, OutputStream}
import java.net.{ServerSocket, InetAddress}
object System_Channel
{
def apply(): System_Channel = new System_Channel
}
class System_Channel private
{
private val server = new ServerSocket(0, 50, Server.localhost)
val address: String = Server.print_address(server.getLocalPort)
val password: String = UUID.random().toString
override def toString: String = address
- def shutdown() { server.close }
+ def shutdown(): Unit = server.close
def rendezvous(): (OutputStream, InputStream) =
{
val socket = server.accept
try {
val out_stream = socket.getOutputStream
val in_stream = socket.getInputStream
if (Byte_Message.read_line(in_stream).map(_.text) == Some(password)) (out_stream, in_stream)
else {
out_stream.close
in_stream.close
error("Failed to connect system channel: bad password")
}
}
finally { shutdown() }
}
}
diff --git a/src/Pure/System/tty_loop.scala b/src/Pure/System/tty_loop.scala
--- a/src/Pure/System/tty_loop.scala
+++ b/src/Pure/System/tty_loop.scala
@@ -1,68 +1,68 @@
/* Title: Pure/System/tty_loop.scala
Author: Makarius
Line-oriented TTY loop.
*/
package isabelle
import java.io.{IOException, Writer, Reader, InputStreamReader, BufferedReader}
class TTY_Loop(
writer: Writer,
reader: Reader,
writer_lock: AnyRef = new Object)
{
private val console_output = Future.thread[Unit]("console_output", uninterruptible = true) {
try {
val result = new StringBuilder(100)
var finished = false
while (!finished) {
var c = -1
var done = false
while (!done && (result.isEmpty || reader.ready)) {
c = reader.read
if (c >= 0) result.append(c.asInstanceOf[Char])
else done = true
}
if (result.nonEmpty) {
System.out.print(result.toString)
System.out.flush()
result.clear
}
else {
reader.close()
finished = true
}
}
}
catch { case e: IOException => case Exn.Interrupt() => }
}
private val console_input = Future.thread[Unit]("console_input", uninterruptible = true) {
val console_reader = new BufferedReader(new InputStreamReader(System.in))
try {
var finished = false
while (!finished) {
console_reader.readLine() match {
case null =>
writer.close()
finished = true
case line =>
writer_lock.synchronized {
writer.write(line)
writer.write("\n")
writer.flush()
}
}
}
}
catch { case e: IOException => case Exn.Interrupt() => }
}
- def join { console_output.join; console_input.join }
+ def join: Unit = { console_output.join; console_input.join }
- def cancel { console_input.cancel }
+ def cancel: Unit = console_input.cancel
}
diff --git a/src/Pure/Thy/bibtex.scala b/src/Pure/Thy/bibtex.scala
--- a/src/Pure/Thy/bibtex.scala
+++ b/src/Pure/Thy/bibtex.scala
@@ -1,702 +1,702 @@
/* Title: Pure/Thy/bibtex.scala
Author: Makarius
BibTeX support.
*/
package isabelle
import java.io.{File => JFile}
import scala.collection.mutable
import scala.util.parsing.combinator.RegexParsers
import scala.util.parsing.input.Reader
object Bibtex
{
/** file format **/
def is_bibtex(name: String): Boolean = name.endsWith(".bib")
class File_Format extends isabelle.File_Format
{
val format_name: String = "bibtex"
val file_ext: String = "bib"
override def theory_suffix: String = "bibtex_file"
override def theory_content(name: String): String =
"""theory "bib" imports Pure begin bibtex_file """ +
Outer_Syntax.quote_string(name) + """ end"""
override def html_document(snapshot: Document.Snapshot): Option[Presentation.HTML_Document] =
{
val name = snapshot.node_name
if (detect(name.node)) {
val title = "Bibliography " + quote(snapshot.node_name.path.file_name)
val content =
Isabelle_System.with_tmp_file("bib", "bib") { bib =>
File.write(bib, snapshot.node.source)
Bibtex.html_output(List(bib), style = "unsort", title = title)
}
Some(Presentation.HTML_Document(title, content))
}
else None
}
}
/** bibtex errors **/
def bibtex_errors(dir: Path, root_name: String): List[String] =
{
val log_path = dir + Path.explode(root_name).ext("blg")
if (log_path.is_file) {
val Error1 = """^(I couldn't open database file .+)$""".r
val Error2 = """^(.+)---line (\d+) of file (.+)""".r
Line.logical_lines(File.read(log_path)).flatMap(line =>
line match {
case Error1(msg) => Some("Bibtex error: " + msg)
case Error2(msg, Value.Int(l), file) =>
val path = File.standard_path(file)
if (Path.is_wellformed(path)) {
val pos = Position.Line_File(l, (dir + Path.explode(path)).canonical.implode)
Some("Bibtex error" + Position.here(pos) + ":\n " + msg)
}
else None
case _ => None
})
}
else Nil
}
/** check database **/
def check_database(database: String): (List[(String, Position.T)], List[(String, Position.T)]) =
{
val chunks = parse(Line.normalize(database))
var chunk_pos = Map.empty[String, Position.T]
val tokens = new mutable.ListBuffer[(Token, Position.T)]
var line = 1
var offset = 1
def make_pos(length: Int): Position.T =
Position.Offset(offset) ::: Position.End_Offset(offset + length) ::: Position.Line(line)
- def advance_pos(tok: Token)
+ def advance_pos(tok: Token): Unit =
{
for (s <- Symbol.iterator(tok.source)) {
if (Symbol.is_newline(s)) line += 1
offset += 1
}
}
def get_line_pos(l: Int): Position.T =
if (0 < l && l <= tokens.length) tokens(l - 1)._2 else Position.none
for (chunk <- chunks) {
val name = chunk.name
if (name != "" && !chunk_pos.isDefinedAt(name)) {
chunk_pos += (name -> make_pos(chunk.heading_length))
}
for (tok <- chunk.tokens) {
tokens += (tok.copy(source = tok.source.replace("\n", " ")) -> make_pos(tok.source.length))
advance_pos(tok)
}
}
Isabelle_System.with_tmp_dir("bibtex")(tmp_dir =>
{
File.write(tmp_dir + Path.explode("root.bib"),
tokens.iterator.map(p => p._1.source).mkString("", "\n", "\n"))
File.write(tmp_dir + Path.explode("root.aux"),
"\\bibstyle{plain}\n\\bibdata{root}\n\\citation{*}")
Isabelle_System.bash("\"$ISABELLE_BIBTEX\" root", cwd = tmp_dir.file)
val Error = """^(.*)---line (\d+) of file root.bib$""".r
val Warning = """^Warning--(.+)$""".r
val Warning_Line = """--line (\d+) of file root.bib$""".r
val Warning_in_Chunk = """^Warning--(.+) in (.+)$""".r
val log_file = tmp_dir + Path.explode("root.blg")
val lines = if (log_file.is_file) Line.logical_lines(File.read(log_file)) else Nil
val (errors, warnings) =
if (lines.isEmpty) (Nil, Nil)
else {
lines.zip(lines.tail ::: List("")).flatMap(
{
case (Error(msg, Value.Int(l)), _) =>
Some((true, (msg, get_line_pos(l))))
case (Warning_in_Chunk(msg, name), _) if chunk_pos.isDefinedAt(name) =>
Some((false, (Word.capitalize(msg + " in entry " + quote(name)), chunk_pos(name))))
case (Warning(msg), Warning_Line(Value.Int(l))) =>
Some((false, (Word.capitalize(msg), get_line_pos(l))))
case (Warning(msg), _) =>
Some((false, (Word.capitalize(msg), Position.none)))
case _ => None
}
).partition(_._1)
}
(errors.map(_._2), warnings.map(_._2))
})
}
object Check_Database extends Scala.Fun("bibtex_check_database")
{
val here = Scala_Project.here
def apply(database: String): String =
{
import XML.Encode._
YXML.string_of_body(pair(list(pair(string, properties)), list(pair(string, properties)))(
check_database(database)))
}
}
/** document model **/
/* entries */
def entries(text: String): List[Text.Info[String]] =
{
val result = new mutable.ListBuffer[Text.Info[String]]
var offset = 0
for (chunk <- Bibtex.parse(text)) {
val end_offset = offset + chunk.source.length
if (chunk.name != "" && !chunk.is_command)
result += Text.Info(Text.Range(offset, end_offset), chunk.name)
offset = end_offset
}
result.toList
}
def entries_iterator[A, B <: Document.Model](models: Map[A, B])
: Iterator[Text.Info[(String, B)]] =
{
for {
(_, model) <- models.iterator
info <- model.bibtex_entries.iterator
} yield info.map((_, model))
}
/* completion */
def completion[A, B <: Document.Model](
history: Completion.History, rendering: Rendering, caret: Text.Offset,
models: Map[A, B]): Option[Completion.Result] =
{
for {
Text.Info(r, name) <- rendering.citations(rendering.before_caret_range(caret)).headOption
name1 <- Completion.clean_name(name)
original <- rendering.get_text(r)
original1 <- Completion.clean_name(Library.perhaps_unquote(original))
entries =
(for {
Text.Info(_, (entry, _)) <- entries_iterator(models)
if entry.toLowerCase.containsSlice(name1.toLowerCase) && entry != original1
} yield entry).toList
if entries.nonEmpty
items =
entries.sorted.map({
case entry =>
val full_name = Long_Name.qualify(Markup.CITATION, entry)
val description = List(entry, "(BibTeX entry)")
val replacement = quote(entry)
Completion.Item(r, original, full_name, description, replacement, 0, false)
}).sorted(history.ordering).take(rendering.options.int("completion_limit"))
} yield Completion.Result(r, original, false, items)
}
/** content **/
private val months = List(
"jan",
"feb",
"mar",
"apr",
"may",
"jun",
"jul",
"aug",
"sep",
"oct",
"nov",
"dec")
def is_month(s: String): Boolean = months.contains(s.toLowerCase)
private val commands = List("preamble", "string")
def is_command(s: String): Boolean = commands.contains(s.toLowerCase)
sealed case class Entry(
kind: String,
required: List[String],
optional_crossref: List[String],
optional_other: List[String])
{
val optional_standard: List[String] = List("url", "doi", "ee")
def is_required(s: String): Boolean = required.contains(s.toLowerCase)
def is_optional(s: String): Boolean =
optional_crossref.contains(s.toLowerCase) ||
optional_other.contains(s.toLowerCase) ||
optional_standard.contains(s.toLowerCase)
def fields: List[String] =
required ::: optional_crossref ::: optional_other ::: optional_standard
def template: String =
"@" + kind + "{,\n" + fields.map(x => " " + x + " = {},\n").mkString + "}\n"
}
val known_entries: List[Entry] =
List(
Entry("Article",
List("author", "title"),
List("journal", "year"),
List("volume", "number", "pages", "month", "note")),
Entry("InProceedings",
List("author", "title"),
List("booktitle", "year"),
List("editor", "volume", "number", "series", "pages", "month", "address",
"organization", "publisher", "note")),
Entry("InCollection",
List("author", "title", "booktitle"),
List("publisher", "year"),
List("editor", "volume", "number", "series", "type", "chapter", "pages",
"edition", "month", "address", "note")),
Entry("InBook",
List("author", "editor", "title", "chapter"),
List("publisher", "year"),
List("volume", "number", "series", "type", "address", "edition", "month", "pages", "note")),
Entry("Proceedings",
List("title", "year"),
List(),
List("booktitle", "editor", "volume", "number", "series", "address", "month",
"organization", "publisher", "note")),
Entry("Book",
List("author", "editor", "title"),
List("publisher", "year"),
List("volume", "number", "series", "address", "edition", "month", "note")),
Entry("Booklet",
List("title"),
List(),
List("author", "howpublished", "address", "month", "year", "note")),
Entry("PhdThesis",
List("author", "title", "school", "year"),
List(),
List("type", "address", "month", "note")),
Entry("MastersThesis",
List("author", "title", "school", "year"),
List(),
List("type", "address", "month", "note")),
Entry("TechReport",
List("author", "title", "institution", "year"),
List(),
List("type", "number", "address", "month", "note")),
Entry("Manual",
List("title"),
List(),
List("author", "organization", "address", "edition", "month", "year", "note")),
Entry("Unpublished",
List("author", "title", "note"),
List(),
List("month", "year")),
Entry("Misc",
List(),
List(),
List("author", "title", "howpublished", "month", "year", "note")))
def get_entry(kind: String): Option[Entry] =
known_entries.find(entry => entry.kind.toLowerCase == kind.toLowerCase)
def is_entry(kind: String): Boolean = get_entry(kind).isDefined
/** tokens and chunks **/
object Token
{
object Kind extends Enumeration
{
val COMMAND = Value("command")
val ENTRY = Value("entry")
val KEYWORD = Value("keyword")
val NAT = Value("natural number")
val STRING = Value("string")
val NAME = Value("name")
val IDENT = Value("identifier")
val SPACE = Value("white space")
val COMMENT = Value("ignored text")
val ERROR = Value("bad input")
}
}
sealed case class Token(kind: Token.Kind.Value, source: String)
{
def is_kind: Boolean =
kind == Token.Kind.COMMAND ||
kind == Token.Kind.ENTRY ||
kind == Token.Kind.IDENT
def is_name: Boolean =
kind == Token.Kind.NAME ||
kind == Token.Kind.IDENT
def is_ignored: Boolean =
kind == Token.Kind.SPACE ||
kind == Token.Kind.COMMENT
def is_malformed: Boolean =
kind == Token.Kind.ERROR
def is_open: Boolean =
kind == Token.Kind.KEYWORD && (source == "{" || source == "(")
}
case class Chunk(kind: String, tokens: List[Token])
{
val source = tokens.map(_.source).mkString
private val content: Option[List[Token]] =
tokens match {
case Token(Token.Kind.KEYWORD, "@") :: body if body.nonEmpty =>
(body.init.filterNot(_.is_ignored), body.last) match {
case (tok :: Token(Token.Kind.KEYWORD, "{") :: toks, Token(Token.Kind.KEYWORD, "}"))
if tok.is_kind => Some(toks)
case (tok :: Token(Token.Kind.KEYWORD, "(") :: toks, Token(Token.Kind.KEYWORD, ")"))
if tok.is_kind => Some(toks)
case _ => None
}
case _ => None
}
def name: String =
content match {
case Some(tok :: _) if tok.is_name => tok.source
case _ => ""
}
def heading_length: Int =
if (name == "") 1
else (0 /: tokens.takeWhile(tok => !tok.is_open)){ case (n, tok) => n + tok.source.length }
def is_ignored: Boolean = kind == "" && tokens.forall(_.is_ignored)
def is_malformed: Boolean = kind == "" || tokens.exists(_.is_malformed)
def is_command: Boolean = Bibtex.is_command(kind) && name != "" && content.isDefined
def is_entry: Boolean = Bibtex.is_entry(kind) && name != "" && content.isDefined
}
/** parsing **/
// context of partial line-oriented scans
abstract class Line_Context
case object Ignored extends Line_Context
case object At extends Line_Context
case class Item_Start(kind: String) extends Line_Context
case class Item_Open(kind: String, end: String) extends Line_Context
case class Item(kind: String, end: String, delim: Delimited) extends Line_Context
case class Delimited(quoted: Boolean, depth: Int)
val Closed = Delimited(false, 0)
private def token(kind: Token.Kind.Value)(source: String): Token = Token(kind, source)
private def keyword(source: String): Token = Token(Token.Kind.KEYWORD, source)
// See also https://ctan.org/tex-archive/biblio/bibtex/base/bibtex.web
// module @.
object Parsers extends RegexParsers
{
/* white space and comments */
override val whiteSpace = "".r
private val space = """[ \t\n\r]+""".r ^^ token(Token.Kind.SPACE)
private val spaces = rep(space)
/* ignored text */
private val ignored: Parser[Chunk] =
rep1("""(?i)([^@]+|@[ \t]*comment)""".r) ^^ {
case ss => Chunk("", List(Token(Token.Kind.COMMENT, ss.mkString))) }
private def ignored_line: Parser[(Chunk, Line_Context)] =
ignored ^^ { case a => (a, Ignored) }
/* delimited string: outermost "..." or {...} and body with balanced {...} */
// see also bibtex.web: scan_a_field_token_and_eat_white, scan_balanced_braces
private def delimited_depth(delim: Delimited): Parser[(String, Delimited)] =
new Parser[(String, Delimited)]
{
require(if (delim.quoted) delim.depth > 0 else delim.depth >= 0,
"bad delimiter depth")
def apply(in: Input) =
{
val start = in.offset
val end = in.source.length
var i = start
var q = delim.quoted
var d = delim.depth
var finished = false
while (!finished && i < end) {
val c = in.source.charAt(i)
if (c == '"' && d == 0) { i += 1; d = 1; q = true }
else if (c == '"' && d == 1 && q) {
i += 1; d = 0; q = false; finished = true
}
else if (c == '{') { i += 1; d += 1 }
else if (c == '}') {
if (d == 1 && !q || d > 1) { i += 1; d -= 1; if (d == 0) finished = true }
else {i = start; finished = true }
}
else if (d > 0) i += 1
else finished = true
}
if (i == start) Failure("bad input", in)
else {
val s = in.source.subSequence(start, i).toString
Success((s, Delimited(q, d)), in.drop(i - start))
}
}
}.named("delimited_depth")
private def delimited: Parser[Token] =
delimited_depth(Closed) ^?
{ case (s, delim) if delim == Closed => Token(Token.Kind.STRING, s) }
private def recover_delimited: Parser[Token] =
"""["{][^@]*""".r ^^ token(Token.Kind.ERROR)
def delimited_line(ctxt: Item): Parser[(Chunk, Line_Context)] =
delimited_depth(ctxt.delim) ^^ { case (s, delim1) =>
(Chunk(ctxt.kind, List(Token(Token.Kind.STRING, s))), ctxt.copy(delim = delim1)) } |
recover_delimited ^^ { case a => (Chunk(ctxt.kind, List(a)), Ignored) }
/* other tokens */
private val at = "@" ^^ keyword
private val nat = "[0-9]+".r ^^ token(Token.Kind.NAT)
private val name = """[\x21-\x7f&&[^"#%'(),={}]]+""".r ^^ token(Token.Kind.NAME)
private val identifier =
"""[\x21-\x7f&&[^"#%'(),={}0-9]][\x21-\x7f&&[^"#%'(),={}]]*""".r
private val ident = identifier ^^ token(Token.Kind.IDENT)
val other_token = "[=#,]".r ^^ keyword | (nat | (ident | space))
/* body */
private val body =
delimited | (recover_delimited | other_token)
private def body_line(ctxt: Item) =
if (ctxt.delim.depth > 0)
delimited_line(ctxt)
else
delimited_line(ctxt) |
other_token ^^ { case a => (Chunk(ctxt.kind, List(a)), ctxt) } |
ctxt.end ^^ { case a => (Chunk(ctxt.kind, List(keyword(a))), Ignored) }
/* items: command or entry */
private val item_kind =
identifier ^^ { case a =>
val kind =
if (is_command(a)) Token.Kind.COMMAND
else if (is_entry(a)) Token.Kind.ENTRY
else Token.Kind.IDENT
Token(kind, a)
}
private val item_begin =
"{" ^^ { case a => ("}", keyword(a)) } |
"(" ^^ { case a => (")", keyword(a)) }
private def item_name(kind: String) =
kind.toLowerCase match {
case "preamble" => failure("")
case "string" => identifier ^^ token(Token.Kind.NAME)
case _ => name
}
private val item_start =
at ~ spaces ~ item_kind ~ spaces ^^
{ case a ~ b ~ c ~ d => (c.source, List(a) ::: b ::: List(c) ::: d) }
private val item: Parser[Chunk] =
(item_start ~ item_begin ~ spaces) into
{ case (kind, a) ~ ((end, b)) ~ c =>
opt(item_name(kind)) ~ rep(body) ~ opt(end ^^ keyword) ^^ {
case d ~ e ~ f => Chunk(kind, a ::: List(b) ::: c ::: d.toList ::: e ::: f.toList) } }
private val recover_item: Parser[Chunk] =
at ~ "[^@]*".r ^^ { case a ~ b => Chunk("", List(a, Token(Token.Kind.ERROR, b))) }
/* chunks */
val chunk: Parser[Chunk] = ignored | (item | recover_item)
def chunk_line(ctxt: Line_Context): Parser[(Chunk, Line_Context)] =
{
ctxt match {
case Ignored =>
ignored_line |
at ^^ { case a => (Chunk("", List(a)), At) }
case At =>
space ^^ { case a => (Chunk("", List(a)), ctxt) } |
item_kind ^^ { case a => (Chunk(a.source, List(a)), Item_Start(a.source)) } |
recover_item ^^ { case a => (a, Ignored) } |
ignored_line
case Item_Start(kind) =>
space ^^ { case a => (Chunk(kind, List(a)), ctxt) } |
item_begin ^^ { case (end, a) => (Chunk(kind, List(a)), Item_Open(kind, end)) } |
recover_item ^^ { case a => (a, Ignored) } |
ignored_line
case Item_Open(kind, end) =>
space ^^ { case a => (Chunk(kind, List(a)), ctxt) } |
item_name(kind) ^^ { case a => (Chunk(kind, List(a)), Item(kind, end, Closed)) } |
body_line(Item(kind, end, Closed)) |
ignored_line
case item_ctxt: Item =>
body_line(item_ctxt) |
ignored_line
case _ => failure("")
}
}
}
/* parse */
def parse(input: CharSequence): List[Chunk] =
Parsers.parseAll(Parsers.rep(Parsers.chunk), Scan.char_reader(input)) match {
case Parsers.Success(result, _) => result
case _ => error("Unexpected failure to parse input:\n" + input.toString)
}
def parse_line(input: CharSequence, context: Line_Context): (List[Chunk], Line_Context) =
{
var in: Reader[Char] = Scan.char_reader(input)
val chunks = new mutable.ListBuffer[Chunk]
var ctxt = context
while (!in.atEnd) {
Parsers.parse(Parsers.chunk_line(ctxt), in) match {
case Parsers.Success((x, c), rest) => chunks += x; ctxt = c; in = rest
case Parsers.NoSuccess(_, rest) =>
error("Unepected failure to parse input:\n" + rest.source.toString)
}
}
(chunks.toList, ctxt)
}
/** HTML output **/
private val output_styles =
List(
"" -> "html-n",
"plain" -> "html-n",
"alpha" -> "html-a",
"named" -> "html-n",
"paragraph" -> "html-n",
"unsort" -> "html-u",
"unsortlist" -> "html-u")
def html_output(bib: List[Path],
title: String = "Bibliography",
body: Boolean = false,
citations: List[String] = List("*"),
style: String = "",
chronological: Boolean = false): String =
{
Isabelle_System.with_tmp_dir("bibtex")(tmp_dir =>
{
/* database files */
val bib_files = bib.map(_.drop_ext)
val bib_names =
{
val names0 = bib_files.map(_.file_name)
if (Library.duplicates(names0).isEmpty) names0
else names0.zipWithIndex.map({ case (name, i) => (i + 1).toString + "-" + name })
}
for ((a, b) <- bib_files zip bib_names) {
Isabelle_System.copy_file(a.ext("bib"), tmp_dir + Path.basic(b).ext("bib"))
}
/* style file */
val bst =
output_styles.toMap.get(style) match {
case Some(base) => base + (if (chronological) "c" else "") + ".bst"
case None =>
error("Bad style for bibtex HTML output: " + quote(style) +
"\n(expected: " + commas_quote(output_styles.map(_._1)) + ")")
}
Isabelle_System.copy_file(Path.explode("$BIB2XHTML_HOME/bst") + Path.explode(bst), tmp_dir)
/* result */
val in_file = Path.explode("bib.aux")
val out_file = Path.explode("bib.html")
File.write(tmp_dir + in_file,
bib_names.mkString("\\bibdata{", ",", "}\n") +
citations.map(cite => "\\citation{" + cite + "}\n").mkString)
Isabelle_System.bash(
"\"$BIB2XHTML_HOME/main/bib2xhtml.pl\" -B \"$ISABELLE_BIBTEX\"" +
" -u -s " + Bash.string(proper_string(style) getOrElse "empty") +
(if (chronological) " -c" else "") +
(if (title != "") " -h " + Bash.string(title) + " " else "") +
" " + File.bash_path(in_file) + " " + File.bash_path(out_file),
cwd = tmp_dir.file).check
val html = File.read(tmp_dir + out_file)
if (body) {
cat_lines(
split_lines(html).
dropWhile(line => !line.startsWith("