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)
   {
-    require(Platform.is_windows)
+    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 >/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_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)
   {
     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)
+    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)
   {
     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/Concurrent/counter.scala b/src/Pure/Concurrent/counter.scala
--- a/src/Pure/Concurrent/counter.scala
+++ b/src/Pure/Concurrent/counter.scala
@@ -1,29 +1,29 @@
 /*  Title:      Pure/Concurrent/counter.scala
     Author:     Makarius
 
 Synchronized counter for unique identifiers < 0.
 
 NB: ML ticks forwards, JVM ticks backwards.
 */
 
 package isabelle
 
 
 object Counter
 {
   type ID = Long
   def make(): Counter = new Counter
 }
 
 final class Counter private
 {
   private var count: Counter.ID = 0
 
   def apply(): Counter.ID = synchronized {
-    require(count > java.lang.Long.MIN_VALUE)
+    require(count > java.lang.Long.MIN_VALUE, "counter overflow")
     count -= 1
     count
   }
 
   override def toString: String = count.toString
 }
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); Exn.release(peek.get) }
+  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 => "<future>"
       case Some(Exn.Exn(_)) => "<failed>"
       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 {}
 }
 
 
 /* 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()
   {
     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) }
     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() }
 
   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)
+      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_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)
+    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)
   {
     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/General/date.scala b/src/Pure/General/date.scala
--- a/src/Pure/General/date.scala
+++ b/src/Pure/General/date.scala
@@ -1,105 +1,105 @@
 /*  Title:      Pure/General/date.scala
     Author:     Makarius
 
 Date and time, with time zone.
 */
 
 package isabelle
 
 
 import java.util.Locale
 import java.time.{Instant, ZonedDateTime, LocalTime, ZoneId, OffsetDateTime}
 import java.time.format.{DateTimeFormatter, DateTimeParseException}
 import java.time.temporal.TemporalAccessor
 
 import scala.annotation.tailrec
 
 
 object Date
 {
   /* format */
 
   object Format
   {
     def make(fmts: List[DateTimeFormatter], tune: String => String = s => s): Format =
     {
-      require(fmts.nonEmpty)
+      require(fmts.nonEmpty, "no date formats")
 
       new Format {
         def apply(date: Date): String = fmts.head.format(date.rep)
         def parse(str: String): Date =
           new Date(ZonedDateTime.from(Formatter.try_variants(fmts, tune(str))))
       }
     }
 
     def apply(pats: String*): Format =
       make(pats.toList.map(Date.Formatter.pattern))
 
     val default: Format = Format("dd-MMM-uuuu HH:mm:ss xx")
     val date: Format = Format("dd-MMM-uuuu")
     val time: Format = Format("HH:mm:ss")
   }
 
   abstract class Format private
   {
     def apply(date: Date): String
     def parse(str: String): Date
 
     def unapply(str: String): Option[Date] =
       try { Some(parse(str)) } catch { case _: DateTimeParseException => None }
   }
 
   object Formatter
   {
     def pattern(pat: String): DateTimeFormatter = DateTimeFormatter.ofPattern(pat)
 
     def variants(pats: List[String], locs: List[Locale] = Nil): List[DateTimeFormatter] =
       pats.flatMap(pat => {
         val fmt = pattern(pat)
         if (locs.isEmpty) List(fmt) else locs.map(fmt.withLocale)
       })
 
     @tailrec def try_variants(fmts: List[DateTimeFormatter], str: String,
       last_exn: Option[DateTimeParseException] = None): TemporalAccessor =
     {
       fmts match {
         case Nil =>
           throw last_exn.getOrElse(new DateTimeParseException("Failed to parse date", str, 0))
         case fmt :: rest =>
           try { ZonedDateTime.from(fmt.parse(str)) }
           catch { case exn: DateTimeParseException => try_variants(rest, str, Some(exn)) }
       }
     }
   }
 
 
   /* date operations */
 
   def timezone_utc: ZoneId = ZoneId.of("UTC")
   def timezone_berlin: ZoneId = ZoneId.of("Europe/Berlin")
 
   def timezone(): ZoneId = ZoneId.systemDefault
 
   def now(zone: ZoneId = timezone()): Date = new Date(ZonedDateTime.now(zone))
 
   def instant(t: Instant, zone: ZoneId = timezone()): Date =
     new Date(ZonedDateTime.ofInstant(t, zone))
 
   def apply(t: Time, zone: ZoneId = timezone()): Date = instant(t.instant, zone)
 }
 
 sealed case class Date(rep: ZonedDateTime)
 {
   def midnight: Date =
     new Date(ZonedDateTime.of(rep.toLocalDate, LocalTime.MIDNIGHT, rep.getZone))
 
   def to(zone: ZoneId): Date = new Date(rep.withZoneSameInstant(zone))
 
   def unix_epoch: Long = rep.toEpochSecond
   def instant: Instant = Instant.from(rep)
   def time: Time = Time.instant(instant)
   def timezone: ZoneId = rep.getZone
 
   def format(fmt: Date.Format = Date.Format.default): String = fmt(this)
   override def toString: String = format()
 }
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,512 +1,512 @@
 /*  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.collection.immutable.PagedSeq
 import scala.util.matching.Regex
 import scala.util.parsing.input.{OffsetPosition, Position => InputPosition,
   Reader, CharSequenceReader}
 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)
+      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)
+      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)
+      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)
+      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)
+      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 }
     }
     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/symbol.scala b/src/Pure/General/symbol.scala
--- a/src/Pure/General/symbol.scala
+++ b/src/Pure/General/symbol.scala
@@ -1,668 +1,668 @@
 /*  Title:      Pure/General/symbol.scala
     Author:     Makarius
 
 Isabelle text symbols.
 */
 
 package isabelle
 
 
 import scala.collection.mutable
 import scala.util.matching.Regex
 import scala.annotation.tailrec
 
 
 object Symbol
 {
   type Symbol = String
 
   // counting Isabelle symbols, starting from 1
   type Offset = Text.Offset
   type Range = Text.Range
 
 
   /* spaces */
 
   val space_char = ' '
   val space = " "
 
   private val static_spaces = space * 4000
 
   def spaces(n: Int): String =
   {
-    require(n >= 0)
+    require(n >= 0, "negative spaces")
     if (n < static_spaces.length) static_spaces.substring(0, n)
     else space * n
   }
 
 
   /* ASCII characters */
 
   def is_ascii_printable(c: Char): Boolean = space_char <= c && c <= '~'
 
   def is_ascii_letter(c: Char): Boolean = 'A' <= c && c <= 'Z' || 'a' <= c && c <= 'z'
 
   def is_ascii_digit(c: Char): Boolean = '0' <= c && c <= '9'
 
   def is_ascii_hex(c: Char): Boolean =
     '0' <= c && c <= '9' || 'A' <= c && c <= 'F' || 'a' <= c && c <= 'f'
 
   def is_ascii_quasi(c: Char): Boolean = c == '_' || c == '\''
 
   def is_ascii_blank(c: Char): Boolean = " \t\n\u000b\f\r".contains(c)
 
   def is_ascii_line_terminator(c: Char): Boolean = "\r\n".contains(c)
 
   def is_ascii_letdig(c: Char): Boolean =
     is_ascii_letter(c) || is_ascii_digit(c) || is_ascii_quasi(c)
 
   def is_ascii_identifier(s: String): Boolean =
     s.length > 0 && is_ascii_letter(s(0)) && s.forall(is_ascii_letdig)
 
   def ascii(c: Char): Symbol =
   {
     if (c > 127) error("Non-ASCII character: " + quote(c.toString))
     else char_symbols(c.toInt)
   }
 
   def is_ascii(s: Symbol): Boolean = s.length == 1 && s(0) < 128
 
 
   /* symbol matching */
 
   private val symbol_total = new Regex("""(?xs)
     [\ud800-\udbff][\udc00-\udfff] | \r\n | \\ < \^? ([A-Za-z][A-Za-z0-9_']*)? >? | .""")
 
   private def is_plain(c: Char): Boolean =
     !(c == '\r' || c == '\\' || Character.isHighSurrogate(c))
 
   def is_malformed(s: Symbol): Boolean =
     s.length match {
       case 1 =>
         val c = s(0)
         Character.isHighSurrogate(c) || Character.isLowSurrogate(c) || c == '\ufffd'
       case 2 =>
         val c1 = s(0)
         val c2 = s(1)
         !(c1 == '\r' && c2 == '\n' || Character.isSurrogatePair(c1, c2))
       case _ => !s.endsWith(">") || s == "\\<>" || s == "\\<^>"
     }
 
   def is_newline(s: Symbol): Boolean =
     s == "\n" || s == "\r" || s == "\r\n"
 
   class Matcher(text: CharSequence)
   {
     private val matcher = symbol_total.pattern.matcher(text)
     def apply(start: Int, end: Int): Int =
     {
-      require(0 <= start && start < end && end <= text.length)
+      require(0 <= start && start < end && end <= text.length, "bad matcher range")
       if (is_plain(text.charAt(start))) 1
       else {
         matcher.region(start, end).lookingAt
         matcher.group.length
       }
     }
   }
 
 
   /* iterator */
 
   private val char_symbols: Array[Symbol] =
     (0 until 256).iterator.map(i => new String(Array(i.toChar))).toArray
 
   def iterator(text: CharSequence): Iterator[Symbol] =
     new Iterator[Symbol]
     {
       private val matcher = new Matcher(text)
       private var i = 0
       def hasNext: Boolean = i < text.length
       def next: Symbol =
       {
         val n = matcher(i, text.length)
         val s =
           if (n == 0) ""
           else if (n == 1) {
             val c = text.charAt(i)
             if (c < char_symbols.length) char_symbols(c)
             else text.subSequence(i, i + n).toString
           }
           else text.subSequence(i, i + n).toString
         i += n
         s
       }
     }
 
   def explode(text: CharSequence): List[Symbol] = iterator(text).toList
 
   def length(text: CharSequence): Int = iterator(text).length
 
   def trim_blanks(text: CharSequence): String =
     Library.trim(is_blank, explode(text)).mkString
 
   def all_blank(str: String): Boolean =
     iterator(str).forall(is_blank)
 
   def trim_blank_lines(text: String): String =
     cat_lines(split_lines(text).dropWhile(all_blank).reverse.dropWhile(all_blank).reverse)
 
 
   /* decoding offsets */
 
   object Index
   {
     private sealed case class Entry(chr: Int, sym: Int)
 
     val empty: Index = new Index(Nil)
 
     def apply(text: CharSequence): Index =
     {
       val matcher = new Matcher(text)
       val buf = new mutable.ListBuffer[Entry]
       var chr = 0
       var sym = 0
       while (chr < text.length) {
         val n = matcher(chr, text.length)
         chr += n
         sym += 1
         if (n > 1) buf += Entry(chr, sym)
       }
       if (buf.isEmpty) empty else new Index(buf.toList)
     }
   }
 
   final class Index private(entries: List[Index.Entry])
   {
     private val hash: Int = entries.hashCode
     private val index: Array[Index.Entry] = entries.toArray
 
     def decode(symbol_offset: Offset): Text.Offset =
     {
       val sym = symbol_offset - 1
       val end = index.length
       @tailrec def bisect(a: Int, b: Int): Int =
       {
         if (a < b) {
           val c = (a + b) / 2
           if (sym < index(c).sym) bisect(a, c)
           else if (c + 1 == end || sym < index(c + 1).sym) c
           else bisect(c + 1, b)
         }
         else -1
       }
       val i = bisect(0, end)
       if (i < 0) sym
       else index(i).chr + sym - index(i).sym
     }
     def decode(symbol_range: Range): Text.Range = symbol_range.map(decode)
 
     override def hashCode: Int = hash
     override def equals(that: Any): Boolean =
       that match {
         case other: Index => index.sameElements(other.index)
         case _ => false
       }
   }
 
 
   /* symbolic text chunks -- without actual text */
 
   object Text_Chunk
   {
     sealed abstract class Name
     case object Default extends Name
     case class Id(id: Document_ID.Generic) extends Name
     case class File(name: String) extends Name
 
     def apply(text: CharSequence): Text_Chunk =
       new Text_Chunk(Text.Range(0, text.length), Index(text))
   }
 
   final class Text_Chunk private(val range: Text.Range, private val index: Index)
   {
     override def hashCode: Int = (range, index).hashCode
     override def equals(that: Any): Boolean =
       that match {
         case other: Text_Chunk =>
           range == other.range &&
           index == other.index
         case _ => false
       }
 
     override def toString: String = "Text_Chunk" + range.toString
 
     def decode(symbol_offset: Offset): Text.Offset = index.decode(symbol_offset)
     def decode(symbol_range: Range): Text.Range = index.decode(symbol_range)
     def incorporate(symbol_range: Range): Option[Text.Range] =
     {
       def in(r: Range): Option[Text.Range] =
         range.try_restrict(decode(r)) match {
           case Some(r1) if !r1.is_singularity => Some(r1)
           case _ => None
         }
      in(symbol_range) orElse in(symbol_range - 1)
     }
   }
 
 
   /* recoding text */
 
   private class Recoder(list: List[(String, String)])
   {
     private val (min, max) =
     {
       var min = '\uffff'
       var max = '\u0000'
       for ((x, _) <- list) {
         val c = x(0)
         if (c < min) min = c
         if (c > max) max = c
       }
       (min, max)
     }
     private val table =
     {
       var tab = Map[String, String]()
       for ((x, y) <- list) {
         tab.get(x) match {
           case None => tab += (x -> y)
           case Some(z) =>
             error("Duplicate symbol mapping of " + quote(x) + " to " + quote(y) + " vs. " + quote(z))
         }
       }
       tab
     }
     def recode(text: String): String =
     {
       val len = text.length
       val matcher = symbol_total.pattern.matcher(text)
       val result = new StringBuilder(len)
       var i = 0
       while (i < len) {
         val c = text(i)
         if (min <= c && c <= max) {
           matcher.region(i, len).lookingAt
           val x = matcher.group
           result.append(table.getOrElse(x, x))
           i = matcher.end
         }
         else { result.append(c); i += 1 }
       }
       result.toString
     }
   }
 
 
 
   /** symbol interpretation **/
 
   val ARGUMENT_CARTOUCHE = "cartouche"
   val ARGUMENT_SPACE_CARTOUCHE = "space_cartouche"
 
   private lazy val symbols =
   {
     val contents =
       for (path <- Path.split(Isabelle_System.getenv("ISABELLE_SYMBOLS")) if path.is_file)
         yield (File.read(path))
     new Interpretation(cat_lines(contents))
   }
 
   private class Interpretation(symbols_spec: String)
   {
     /* read symbols */
 
     private val No_Decl = new Regex("""(?xs) ^\s* (?: \#.* )? $ """)
     private val Key = new Regex("""(?xs) (.+): """)
 
     private def read_decl(decl: String): (Symbol, Properties.T) =
     {
       def err() = error("Bad symbol declaration: " + decl)
 
       def read_props(props: List[String]): Properties.T =
       {
         props match {
           case Nil => Nil
           case _ :: Nil => err()
           case Key(x) :: y :: rest => (x -> y.replace('\u2423', ' ')) :: read_props(rest)
           case _ => err()
         }
       }
       decl.split("\\s+").toList match {
         case sym :: props if sym.length > 1 && !is_malformed(sym) =>
           (sym, read_props(props))
         case _ => err()
       }
     }
 
     private val symbols: List[(Symbol, Properties.T)] =
       (((List.empty[(Symbol, Properties.T)], Set.empty[Symbol]) /:
           split_lines(symbols_spec).reverse)
         { case (res, No_Decl()) => res
           case ((list, known), decl) =>
             val (sym, props) = read_decl(decl)
             if (known(sym)) (list, known)
             else ((sym, props) :: list, known + sym)
         })._1
 
 
     /* basic properties */
 
     val properties: Map[Symbol, Properties.T] = Map(symbols: _*)
 
     val names: Map[Symbol, (String, String)] =
     {
       val Name = new Regex("""\\<\^?([A-Za-z][A-Za-z0-9_']*)>""")
       val Argument = new Properties.String("argument")
       def argument(sym: Symbol, props: Properties.T): String =
         props match {
           case Argument(arg) =>
             if (arg == ARGUMENT_CARTOUCHE || arg == ARGUMENT_SPACE_CARTOUCHE) arg
             else error("Bad argument: " + quote(arg) + " for symbol " + quote(sym))
           case _ => ""
         }
       Map((for ((sym @ Name(a), props) <- symbols) yield sym -> (a, argument(sym, props))): _*)
     }
 
     val groups: List[(String, List[Symbol])] =
       symbols.flatMap({ case (sym, props) =>
         val gs = for (("group", g) <- props) yield g
         if (gs.isEmpty) List(sym -> "unsorted") else gs.map(sym -> _)
       }).groupBy(_._2).toList.map({ case (group, list) => (group, list.map(_._1)) })
         .sortBy(_._1)
 
     val abbrevs: Multi_Map[Symbol, String] =
       Multi_Map((
         for {
           (sym, props) <- symbols
           ("abbrev", a) <- props.reverse
         } yield sym -> a): _*)
 
     val codes: List[(Symbol, Int)] =
     {
       val Code = new Properties.String("code")
       for {
         (sym, props) <- symbols
         code <-
           props match {
             case Code(s) =>
               try { Some(Integer.decode(s).intValue) }
               catch { case _: NumberFormatException => error("Bad code for symbol " + sym) }
             case _ => None
           }
       } yield {
         if (code < 128) error("Illegal ASCII code for symbol " + sym)
         else (sym, code)
       }
     }
 
 
     /* recoding */
 
     private val (decoder, encoder) =
     {
       val mapping =
         for ((sym, code) <- codes) yield (sym, new String(Character.toChars(code)))
       (new Recoder(mapping), new Recoder(for ((x, y) <- mapping) yield (y, x)))
     }
 
     def decode(text: String): String = decoder.recode(text)
     def encode(text: String): String = encoder.recode(text)
 
     private def recode_set(elems: String*): Set[String] =
     {
       val content = elems.toList
       Set((content ::: content.map(decode)): _*)
     }
 
     private def recode_map[A](elems: (String, A)*): Map[String, A] =
     {
       val content = elems.toList
       Map((content ::: content.map({ case (sym, a) => (decode(sym), a) })): _*)
     }
 
 
     /* user fonts */
 
     private val Font = new Properties.String("font")
     val fonts: Map[Symbol, String] =
       recode_map((for ((sym, Font(font)) <- symbols) yield sym -> font): _*)
 
     val font_names: List[String] = Set(fonts.toList.map(_._2): _*).toList
     val font_index: Map[String, Int] = Map((font_names zip font_names.indices.toList): _*)
 
 
     /* classification */
 
     val letters: Set[String] = recode_set(
       "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
       "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",
       "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",
       "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
 
       "\\<A>", "\\<B>", "\\<C>", "\\<D>", "\\<E>", "\\<F>", "\\<G>",
       "\\<H>", "\\<I>", "\\<J>", "\\<K>", "\\<L>", "\\<M>", "\\<N>",
       "\\<O>", "\\<P>", "\\<Q>", "\\<R>", "\\<S>", "\\<T>", "\\<U>",
       "\\<V>", "\\<W>", "\\<X>", "\\<Y>", "\\<Z>", "\\<a>", "\\<b>",
       "\\<c>", "\\<d>", "\\<e>", "\\<f>", "\\<g>", "\\<h>", "\\<i>",
       "\\<j>", "\\<k>", "\\<l>", "\\<m>", "\\<n>", "\\<o>", "\\<p>",
       "\\<q>", "\\<r>", "\\<s>", "\\<t>", "\\<u>", "\\<v>", "\\<w>",
       "\\<x>", "\\<y>", "\\<z>",
 
       "\\<AA>", "\\<BB>", "\\<CC>", "\\<DD>", "\\<EE>", "\\<FF>",
       "\\<GG>", "\\<HH>", "\\<II>", "\\<JJ>", "\\<KK>", "\\<LL>",
       "\\<MM>", "\\<NN>", "\\<OO>", "\\<PP>", "\\<QQ>", "\\<RR>",
       "\\<SS>", "\\<TT>", "\\<UU>", "\\<VV>", "\\<WW>", "\\<XX>",
       "\\<YY>", "\\<ZZ>", "\\<aa>", "\\<bb>", "\\<cc>", "\\<dd>",
       "\\<ee>", "\\<ff>", "\\<gg>", "\\<hh>", "\\<ii>", "\\<jj>",
       "\\<kk>", "\\<ll>", "\\<mm>", "\\<nn>", "\\<oo>", "\\<pp>",
       "\\<qq>", "\\<rr>", "\\<ss>", "\\<tt>", "\\<uu>", "\\<vv>",
       "\\<ww>", "\\<xx>", "\\<yy>", "\\<zz>",
 
       "\\<alpha>", "\\<beta>", "\\<gamma>", "\\<delta>", "\\<epsilon>",
       "\\<zeta>", "\\<eta>", "\\<theta>", "\\<iota>", "\\<kappa>",
       "\\<mu>", "\\<nu>", "\\<xi>", "\\<pi>", "\\<rho>", "\\<sigma>",
       "\\<tau>", "\\<upsilon>", "\\<phi>", "\\<chi>", "\\<psi>",
       "\\<omega>", "\\<Gamma>", "\\<Delta>", "\\<Theta>", "\\<Lambda>",
       "\\<Xi>", "\\<Pi>", "\\<Sigma>", "\\<Upsilon>", "\\<Phi>",
       "\\<Psi>", "\\<Omega>")
 
     val blanks: Set[String] = recode_set(space, "\t", "\n", "\u000B", "\f", "\r", "\r\n")
 
     val sym_chars =
       Set("!", "#", "$", "%", "&", "*", "+", "-", "/", "<", "=", ">", "?", "@", "^", "_", "|", "~")
 
     val symbolic: Set[String] = recode_set((for {(sym, _) <- symbols; if raw_symbolic(sym)} yield sym): _*)
 
 
     /* misc symbols */
 
     val newline_decoded = decode(newline)
     val comment_decoded = decode(comment)
     val cancel_decoded = decode(cancel)
     val latex_decoded = decode(latex)
     val marker_decoded = decode(marker)
     val open_decoded = decode(open)
     val close_decoded = decode(close)
 
 
     /* control symbols */
 
     val control_decoded: Set[Symbol] =
       Set((for ((sym, _) <- symbols if sym.startsWith("\\<^")) yield decode(sym)): _*)
 
     val sub_decoded = decode(sub)
     val sup_decoded = decode(sup)
     val bold_decoded = decode(bold)
     val emph_decoded = decode(emph)
     val bsub_decoded = decode(bsub)
     val esub_decoded = decode(esub)
     val bsup_decoded = decode(bsup)
     val esup_decoded = decode(esup)
   }
 
 
   /* tables */
 
   def properties: Map[Symbol, Properties.T] = symbols.properties
   def names: Map[Symbol, (String, String)] = symbols.names
   def groups: List[(String, List[Symbol])] = symbols.groups
   def abbrevs: Multi_Map[Symbol, String] = symbols.abbrevs
   def codes: List[(Symbol, Int)] = symbols.codes
   def groups_code: List[(String, List[Symbol])] =
   {
     val has_code = codes.iterator.map(_._1).toSet
     groups.flatMap({ case (group, symbols) =>
       val symbols1 = symbols.filter(has_code)
       if (symbols1.isEmpty) None else Some((group, symbols1))
     })
   }
 
   lazy val is_code: Int => Boolean = codes.map(_._2).toSet
   def decode(text: String): String = symbols.decode(text)
   def encode(text: String): String = symbols.encode(text)
 
   def decode_yxml(text: String, cache: XML.Cache = XML.Cache.none): XML.Body =
     YXML.parse_body(decode(text), cache = cache)
 
   def decode_yxml_failsafe(text: String, cache: XML.Cache = XML.Cache.none): XML.Body =
     YXML.parse_body_failsafe(decode(text), cache = cache)
 
   def encode_yxml(body: XML.Body): String = encode(YXML.string_of_body(body))
 
   def decode_strict(text: String): String =
   {
     val decoded = decode(text)
     if (encode(decoded) == text) decoded
     else {
       val bad = new mutable.ListBuffer[Symbol]
       for (s <- iterator(text) if encode(decode(s)) != s && !bad.contains(s))
         bad += s
       error("Bad Unicode symbols in text: " + commas_quote(bad))
     }
   }
 
   def output(unicode_symbols: Boolean, text: String): String =
     if (unicode_symbols) Symbol.decode(text) else Symbol.encode(text)
 
   def fonts: Map[Symbol, String] = symbols.fonts
   def font_names: List[String] = symbols.font_names
   def font_index: Map[String, Int] = symbols.font_index
   def lookup_font(sym: Symbol): Option[Int] = symbols.fonts.get(sym).map(font_index(_))
 
 
   /* classification */
 
   def is_letter(sym: Symbol): Boolean = symbols.letters.contains(sym)
   def is_digit(sym: Symbol): Boolean = sym.length == 1 && '0' <= sym(0) && sym(0) <= '9'
   def is_quasi(sym: Symbol): Boolean = sym == "_" || sym == "'"
   def is_letdig(sym: Symbol): Boolean = is_letter(sym) || is_digit(sym) || is_quasi(sym)
   def is_blank(sym: Symbol): Boolean = symbols.blanks.contains(sym)
 
 
   /* symbolic newline */
 
   val newline: Symbol = "\\<newline>"
   def newline_decoded: Symbol = symbols.newline_decoded
 
   def print_newlines(str: String): String =
     if (str.contains('\n'))
       (for (s <- iterator(str)) yield { if (s == "\n") newline_decoded else s }).mkString
     else str
 
 
   /* formal comments */
 
   val comment: Symbol = "\\<comment>"
   val cancel: Symbol = "\\<^cancel>"
   val latex: Symbol = "\\<^latex>"
   val marker: Symbol = "\\<^marker>"
 
   def comment_decoded: Symbol = symbols.comment_decoded
   def cancel_decoded: Symbol = symbols.cancel_decoded
   def latex_decoded: Symbol = symbols.latex_decoded
   def marker_decoded: Symbol = symbols.marker_decoded
 
 
   /* cartouches */
 
   val open: Symbol = "\\<open>"
   val close: Symbol = "\\<close>"
 
   def open_decoded: Symbol = symbols.open_decoded
   def close_decoded: Symbol = symbols.close_decoded
 
   def is_open(sym: Symbol): Boolean = sym == open_decoded || sym == open
   def is_close(sym: Symbol): Boolean = sym == close_decoded || sym == close
 
   def cartouche(s: String): String = open + s + close
   def cartouche_decoded(s: String): String = open_decoded + s + close_decoded
 
 
   /* symbols for symbolic identifiers */
 
   private def raw_symbolic(sym: Symbol): Boolean =
     sym.startsWith("\\<") && sym.endsWith(">") && !sym.startsWith("\\<^")
 
   def is_symbolic(sym: Symbol): Boolean =
     !is_open(sym) && !is_close(sym) && (raw_symbolic(sym) || symbols.symbolic.contains(sym))
 
   def is_symbolic_char(sym: Symbol): Boolean = symbols.sym_chars.contains(sym)
 
 
   /* control symbols */
 
   val control_prefix = "\\<^"
   val control_suffix = ">"
 
   def control_name(sym: Symbol): Option[String] =
     if (is_control_encoded(sym))
       Some(sym.substring(control_prefix.length, sym.length - control_suffix.length))
     else None
 
   def is_control_encoded(sym: Symbol): Boolean =
     sym.startsWith(control_prefix) && sym.endsWith(control_suffix)
 
   def is_control(sym: Symbol): Boolean =
     is_control_encoded(sym) || symbols.control_decoded.contains(sym)
 
   def is_controllable(sym: Symbol): Boolean =
     !is_blank(sym) && !is_control(sym) && !is_open(sym) && !is_close(sym) &&
     !is_malformed(sym) && sym != "\""
 
   val sub = "\\<^sub>"
   val sup = "\\<^sup>"
   val bold = "\\<^bold>"
   val emph = "\\<^emph>"
   val bsub = "\\<^bsub>"
   val esub = "\\<^esub>"
   val bsup = "\\<^bsup>"
   val esup = "\\<^esup>"
 
   def sub_decoded: Symbol = symbols.sub_decoded
   def sup_decoded: Symbol = symbols.sup_decoded
   def bold_decoded: Symbol = symbols.bold_decoded
   def emph_decoded: Symbol = symbols.emph_decoded
   def bsub_decoded: Symbol = symbols.bsub_decoded
   def esub_decoded: Symbol = symbols.esub_decoded
   def bsup_decoded: Symbol = symbols.bsup_decoded
   def esup_decoded: Symbol = symbols.esup_decoded
 
 
   /* metric */
 
   def is_printable(sym: Symbol): Boolean =
     if (is_ascii(sym)) is_ascii_printable(sym(0))
     else !is_control(sym)
 
   object Metric extends Pretty.Metric
   {
     val unit = 1.0
     def apply(str: String): Double =
       (for (s <- iterator(str)) yield {
         val sym = encode(s)
         if (sym.startsWith("\\<long") || sym.startsWith("\\<Long")) 2
         else if (is_printable(sym)) 1
         else 0
       }).sum
   }
 }
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()
     {
       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)
     {
       flush()
       code = x
       rest = n
     }
     def push(x: Int)
     {
       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)
+    require(0 <= start && start <= end && end <= buffer.length, "bad decode range")
     new Decode_Chars(decode, buffer, start, end)
   }
 }
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)
+    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])
     {
       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()
     {
       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_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)
   {
     def progress_stdout(line: String)
     {
       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))
+    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])
   {
     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/command.scala b/src/Pure/PIDE/command.scala
--- a/src/Pure/PIDE/command.scala
+++ b/src/Pure/PIDE/command.scala
@@ -1,651 +1,651 @@
 /*  Title:      Pure/PIDE/command.scala
     Author:     Fabian Immler, TU Munich
     Author:     Makarius
 
 Prover commands with accumulated results from execution.
 */
 
 package isabelle
 
 
 import scala.collection.immutable.SortedMap
 
 
 object Command
 {
   /* blobs */
 
   object Blob
   {
     def read_file(name: Document.Node.Name, src_path: Path): Blob =
     {
       val bytes = Bytes.read(name.path)
       val chunk = Symbol.Text_Chunk(bytes.text)
       Blob(name, src_path, Some((bytes.sha1_digest, chunk)))
     }
   }
 
   sealed case class Blob(
     name: Document.Node.Name,
     src_path: Path,
     content: Option[(SHA1.Digest, Symbol.Text_Chunk)])
   {
     def read_file: Bytes = Bytes.read(name.path)
 
     def chunk_file: Symbol.Text_Chunk.File =
       Symbol.Text_Chunk.File(name.node)
   }
 
   object Blobs_Info
   {
     val none: Blobs_Info = Blobs_Info(Nil)
 
     def errors(msgs: List[String]): Blobs_Info =
       Blobs_Info(msgs.map(msg => Exn.Exn[Blob](ERROR(msg))))
   }
 
   sealed case class Blobs_Info(blobs: List[Exn.Result[Blob]], index: Int = -1)
 
 
 
   /** accumulated results from prover **/
 
   /* results */
 
   object Results
   {
     type Entry = (Long, XML.Elem)
     val empty: Results = new Results(SortedMap.empty)
     def make(args: TraversableOnce[Results.Entry]): Results = (empty /: args)(_ + _)
     def merge(args: TraversableOnce[Results]): Results = (empty /: args)(_ ++ _)
   }
 
   final class Results private(private val rep: SortedMap[Long, XML.Elem])
   {
     def is_empty: Boolean = rep.isEmpty
     def defined(serial: Long): Boolean = rep.isDefinedAt(serial)
     def get(serial: Long): Option[XML.Elem] = rep.get(serial)
     def iterator: Iterator[Results.Entry] = rep.iterator
 
     def + (entry: Results.Entry): Results =
       if (defined(entry._1)) this
       else new Results(rep + entry)
 
     def ++ (other: Results): Results =
       if (this eq other) this
       else if (rep.isEmpty) other
       else (this /: other.iterator)(_ + _)
 
     override def hashCode: Int = rep.hashCode
     override def equals(that: Any): Boolean =
       that match {
         case other: Results => rep == other.rep
         case _ => false
       }
     override def toString: String = iterator.mkString("Results(", ", ", ")")
   }
 
 
   /* exports */
 
   object Exports
   {
     type Entry = (Long, Export.Entry)
     val empty: Exports = new Exports(SortedMap.empty)
     def merge(args: TraversableOnce[Exports]): Exports = (empty /: args)(_ ++ _)
   }
 
   final class Exports private(private val rep: SortedMap[Long, Export.Entry])
   {
     def is_empty: Boolean = rep.isEmpty
     def iterator: Iterator[Exports.Entry] = rep.iterator
 
     def + (entry: Exports.Entry): Exports =
       if (rep.isDefinedAt(entry._1)) this
       else new Exports(rep + entry)
 
     def ++ (other: Exports): Exports =
       if (this eq other) this
       else if (rep.isEmpty) other
       else (this /: other.iterator)(_ + _)
 
     override def hashCode: Int = rep.hashCode
     override def equals(that: Any): Boolean =
       that match {
         case other: Exports => rep == other.rep
         case _ => false
       }
     override def toString: String = iterator.mkString("Exports(", ", ", ")")
   }
 
 
   /* markups */
 
   object Markup_Index
   {
     val markup: Markup_Index = Markup_Index(false, Symbol.Text_Chunk.Default)
     def blob(blob: Blob): Markup_Index = Markup_Index(false, blob.chunk_file)
   }
 
   sealed case class Markup_Index(status: Boolean, chunk_name: Symbol.Text_Chunk.Name)
 
   object Markups
   {
     type Entry = (Markup_Index, Markup_Tree)
     val empty: Markups = new Markups(Map.empty)
     def init(markup: Markup_Tree): Markups = new Markups(Map(Markup_Index.markup -> markup))
     def make(args: TraversableOnce[Entry]): Markups = (empty /: args)(_ + _)
     def merge(args: TraversableOnce[Markups]): Markups = (empty /: args)(_ ++ _)
   }
 
   final class Markups private(private val rep: Map[Markup_Index, Markup_Tree])
   {
     def is_empty: Boolean = rep.isEmpty
 
     def apply(index: Markup_Index): Markup_Tree =
       rep.getOrElse(index, Markup_Tree.empty)
 
     def add(index: Markup_Index, markup: Text.Markup): Markups =
       new Markups(rep + (index -> (this(index) + markup)))
 
     def + (entry: Markups.Entry): Markups =
     {
       val (index, tree) = entry
       new Markups(rep + (index -> (this(index).merge(tree, Text.Range.full, Markup.Elements.full))))
     }
 
     def ++ (other: Markups): Markups =
       if (this eq other) this
       else if (rep.isEmpty) other
       else (this /: other.rep.iterator)(_ + _)
 
     def redirection_iterator: Iterator[Document_ID.Generic] =
       for (Markup_Index(_, Symbol.Text_Chunk.Id(id)) <- rep.keysIterator)
         yield id
 
     def redirect(other_id: Document_ID.Generic): Markups =
     {
       val rep1 =
         (for {
           (Markup_Index(status, Symbol.Text_Chunk.Id(id)), markup) <- rep.iterator
           if other_id == id
         } yield (Markup_Index(status, Symbol.Text_Chunk.Default), markup)).toMap
       if (rep1.isEmpty) Markups.empty else new Markups(rep1)
     }
 
     override def hashCode: Int = rep.hashCode
     override def equals(that: Any): Boolean =
       that match {
         case other: Markups => rep == other.rep
         case _ => false
       }
     override def toString: String = rep.iterator.mkString("Markups(", ", ", ")")
   }
 
 
   /* state */
 
   object State
   {
     def get_result(states: List[State], serial: Long): Option[XML.Elem] =
       states.find(st => st.results.defined(serial)).map(st => st.results.get(serial).get)
 
     def get_result_proper(states: List[State], props: Properties.T): Option[Results.Entry] =
       for {
         serial <- Markup.Serial.unapply(props)
         elem <- get_result(states, serial)
         if elem.body.nonEmpty
       } yield serial -> elem
 
     def merge_results(states: List[State]): Results =
       Results.merge(states.map(_.results))
 
     def merge_exports(states: List[State]): Exports =
       Exports.merge(states.map(_.exports))
 
     def merge_markups(states: List[State]): Markups =
       Markups.merge(states.map(_.markups))
 
     def merge_markup(states: List[State], index: Markup_Index,
         range: Text.Range, elements: Markup.Elements): Markup_Tree =
       Markup_Tree.merge(states.map(_.markup(index)), range, elements)
 
     def merge(command: Command, states: List[State]): State =
       State(command, states.flatMap(_.status), merge_results(states),
         merge_exports(states), merge_markups(states))
   }
 
   sealed case class State(
     command: Command,
     status: List[Markup] = Nil,
     results: Results = Results.empty,
     exports: Exports = Exports.empty,
     markups: Markups = Markups.empty)
   {
     def initialized: Boolean = status.exists(markup => markup.name == Markup.INITIALIZED)
     def consolidating: Boolean = status.exists(markup => markup.name == Markup.CONSOLIDATING)
     def consolidated: Boolean = status.exists(markup => markup.name == Markup.CONSOLIDATED)
 
     lazy val maybe_consolidated: Boolean =
     {
       var touched = false
       var forks = 0
       var runs = 0
       for (markup <- status) {
         markup.name match {
           case Markup.FORKED => touched = true; forks += 1
           case Markup.JOINED => forks -= 1
           case Markup.RUNNING => touched = true; runs += 1
           case Markup.FINISHED => runs -= 1
           case _ =>
         }
       }
       touched && forks == 0 && runs == 0
     }
 
     lazy val document_status: Document_Status.Command_Status =
     {
       val warnings =
         if (results.iterator.exists(p => Protocol.is_warning(p._2) || Protocol.is_legacy(p._2)))
           List(Markup(Markup.WARNING, Nil))
         else Nil
       val errors =
         if (results.iterator.exists(p => Protocol.is_error(p._2)))
           List(Markup(Markup.ERROR, Nil))
         else Nil
       Document_Status.Command_Status.make((warnings ::: errors ::: status).iterator)
     }
 
     def markup(index: Markup_Index): Markup_Tree = markups(index)
 
     def redirect(other_command: Command): Option[State] =
     {
       val markups1 = markups.redirect(other_command.id)
       if (markups1.is_empty) None
       else Some(new State(other_command, markups = markups1))
     }
 
     private def add_status(st: Markup): State =
       copy(status = st :: status)
 
     private def add_result(entry: Results.Entry): State =
       copy(results = results + entry)
 
     def add_export(entry: Exports.Entry): Option[State] =
       if (command.node_name.theory == entry._2.theory_name) Some(copy(exports = exports + entry))
       else None
 
     private def add_markup(
       status: Boolean, chunk_name: Symbol.Text_Chunk.Name, m: Text.Markup): State =
     {
       val markups1 =
         if (status || Document_Status.Command_Status.liberal_elements(m.info.name))
           markups.add(Markup_Index(true, chunk_name), m)
         else markups
       copy(markups = markups1.add(Markup_Index(false, chunk_name), m))
     }
 
     def accumulate(
         self_id: Document_ID.Generic => Boolean,
         other_id: (Document.Node.Name, Document_ID.Generic) =>
           Option[(Symbol.Text_Chunk.Id, Symbol.Text_Chunk)],
         message: XML.Elem,
         cache: XML.Cache): State =
       message match {
         case XML.Elem(Markup(Markup.STATUS, _), msgs) =>
           if (command.span.is_theory) this
           else {
             (this /: msgs)((state, msg) =>
               msg match {
                 case elem @ XML.Elem(markup, Nil) =>
                   state.
                     add_status(markup).
                     add_markup(true, Symbol.Text_Chunk.Default, Text.Info(command.core_range, elem))
                 case _ =>
                   Output.warning("Ignored status message: " + msg)
                   state
               })
           }
 
         case XML.Elem(Markup(Markup.REPORT, atts0), msgs) =>
           (this /: msgs)((state, msg) =>
             {
               def bad(): Unit = Output.warning("Ignored report message: " + msg)
 
               msg match {
                 case XML.Elem(Markup(name, atts), args) =>
                   command.reported_position(atts) orElse command.reported_position(atts0) match {
                     case Some((id, chunk_name, target_range)) =>
                       val target =
                         if (self_id(id) && command.chunks.isDefinedAt(chunk_name))
                           Some((chunk_name, command.chunks(chunk_name)))
                         else if (chunk_name == Symbol.Text_Chunk.Default)
                           other_id(command.node_name, id)
                         else None
 
                       (target, target_range) match {
                         case (Some((target_name, target_chunk)), Some(symbol_range))
                         if !symbol_range.is_singularity =>
                           target_chunk.incorporate(symbol_range) match {
                             case Some(range) =>
                               val props = atts.filterNot(Markup.position_property)
                               val elem = cache.elem(XML.Elem(Markup(name, props), args))
                               state.add_markup(false, target_name, Text.Info(range, elem))
                             case None => bad(); state
                           }
                         case _ =>
                           // silently ignore excessive reports
                           state
                       }
 
                     case _ => bad(); state
                   }
                 case _ => bad(); state
               }
             })
 
         case XML.Elem(Markup(name, props), body) =>
           props match {
             case Markup.Serial(i) =>
               val markup_message =
                 cache.elem(XML.Elem(Markup(Markup.message(name), props), body))
               val message_markup =
                 cache.elem(XML.elem(Markup(name, props.filter(p => p._1 == Markup.SERIAL))))
 
               var st = add_result(i -> markup_message)
               if (Protocol.is_inlined(message)) {
                 for {
                   (chunk_name, chunk) <- command.chunks.iterator
                   range <- command.message_positions(self_id, chunk_name, chunk, message)
                 } st = st.add_markup(false, chunk_name, Text.Info(range, message_markup))
               }
               st
 
             case _ =>
               Output.warning("Ignored message without serial number: " + message)
               this
           }
       }
   }
 
 
 
   /** static content **/
 
   /* make commands */
 
   def apply(
     id: Document_ID.Command,
     node_name: Document.Node.Name,
     blobs_info: Blobs_Info,
     span: Command_Span.Span): Command =
   {
     val (source, span1) = span.compact_source
     new Command(id, node_name, blobs_info, span1, source, Results.empty, Markups.empty)
   }
 
   val empty: Command =
     Command(Document_ID.none, Document.Node.Name.empty, Blobs_Info.none, Command_Span.empty)
 
   def unparsed(
     source: String,
     theory: Boolean = false,
     id: Document_ID.Command = Document_ID.none,
     node_name: Document.Node.Name = Document.Node.Name.empty,
     blobs_info: Blobs_Info = Blobs_Info.none,
     results: Results = Results.empty,
     markups: Markups = Markups.empty): Command =
   {
     val (source1, span1) = Command_Span.unparsed(source, theory).compact_source
     new Command(id, node_name, blobs_info, span1, source1, results, markups)
   }
 
   def text(source: String): Command = unparsed(source)
 
   def rich_text(id: Document_ID.Command, results: Results, body: XML.Body): Command =
     unparsed(XML.content(body), id = id, results = results,
       markups = Markups.init(Markup_Tree.from_XML(body)))
 
 
   /* edits and perspective */
 
   type Edit = (Option[Command], Option[Command])
 
   object Perspective
   {
     val empty: Perspective = Perspective(Nil)
   }
 
   sealed case class Perspective(commands: List[Command])  // visible commands in canonical order
   {
     def is_empty: Boolean = commands.isEmpty
 
     def same(that: Perspective): Boolean =
     {
       val cmds1 = this.commands
       val cmds2 = that.commands
-      require(!cmds1.exists(_.is_undefined))
-      require(!cmds2.exists(_.is_undefined))
+      require(!cmds1.exists(_.is_undefined), "cmds1 not defined")
+      require(!cmds2.exists(_.is_undefined), "cmds2 not defined")
       cmds1.length == cmds2.length &&
         (cmds1.iterator zip cmds2.iterator).forall({ case (c1, c2) => c1.id == c2.id })
     }
   }
 
 
   /* blobs: inlined errors and auxiliary files */
 
   def blobs_info(
     resources: Resources,
     syntax: Outer_Syntax,
     get_blob: Document.Node.Name => Option[Document.Blob],
     can_import: Document.Node.Name => Boolean,
     node_name: Document.Node.Name,
     span: Command_Span.Span): Blobs_Info =
   {
     span.name match {
       // inlined errors
       case Thy_Header.THEORY =>
         val reader = span.content_reader
         val header = resources.check_thy(node_name, span.content_reader)
         val imports_pos = header.imports_pos
         val raw_imports =
           try {
             val read_imports = Thy_Header.read(node_name, reader).imports.map(_._1)
             if (imports_pos.length == read_imports.length) read_imports else error("")
           }
           catch { case _: Throwable => List.fill(header.imports.length)("") }
 
         val errors =
           for { ((import_name, pos), s) <- imports_pos zip raw_imports if !can_import(import_name) }
           yield {
             val completion =
               if (Thy_Header.is_base_name(s)) resources.complete_import_name(node_name, s) else Nil
             "Bad theory import " +
               Markup.Path(import_name.node).markup(quote(import_name.toString)) +
               Position.here(pos) + Completion.report_theories(pos, completion)
           }
         Blobs_Info.errors(errors)
 
       // auxiliary files
       case _ =>
         val loaded_files = span.loaded_files(syntax)
         val blobs =
           loaded_files.files.map(file =>
             (Exn.capture {
               val src_path = Path.explode(file)
               val name = Document.Node.Name(resources.append(node_name, src_path))
               val content = get_blob(name).map(blob => (blob.bytes.sha1_digest, blob.chunk))
               Blob(name, src_path, content)
             }).user_error)
         Blobs_Info(blobs, index = loaded_files.index)
     }
   }
 
   def build_blobs_info(
     syntax: Outer_Syntax,
     node_name: Document.Node.Name,
     load_commands: List[Command_Span.Span]): Blobs_Info =
   {
     val blobs =
       for {
         span <- load_commands
         file <- span.loaded_files(syntax).files
       } yield {
         (Exn.capture {
           val dir = node_name.master_dir_path
           val src_path = Path.explode(file)
           val name = Document.Node.Name((dir + src_path).expand.implode_symbolic)
           Blob.read_file(name, src_path)
         }).user_error
       }
     Blobs_Info(blobs)
   }
 }
 
 
 final class Command private(
     val id: Document_ID.Command,
     val node_name: Document.Node.Name,
     val blobs_info: Command.Blobs_Info,
     val span: Command_Span.Span,
     val source: String,
     val init_results: Command.Results,
     val init_markups: Command.Markups)
 {
   override def toString: String = id + "/" + span.kind.toString
 
 
   /* classification */
 
   def is_proper: Boolean = span.kind.isInstanceOf[Command_Span.Command_Span]
   def is_ignored: Boolean = span.kind == Command_Span.Ignored_Span
 
   def is_undefined: Boolean = id == Document_ID.none
   val is_unparsed: Boolean = span.content.exists(_.is_unparsed)
   val is_unfinished: Boolean = span.content.exists(_.is_unfinished)
 
   def potentially_initialized: Boolean = span.name == Thy_Header.THEORY
 
 
   /* blobs */
 
   def blobs: List[Exn.Result[Command.Blob]] = blobs_info.blobs
   def blobs_index: Int = blobs_info.index
 
   def blobs_ok: Boolean =
     blobs.forall({ case Exn.Res(_) => true case _ => false })
 
   def blobs_names: List[Document.Node.Name] =
     for (Exn.Res(blob) <- blobs) yield blob.name
 
   def blobs_undefined: List[Document.Node.Name] =
     for (Exn.Res(blob) <- blobs if blob.content.isEmpty) yield blob.name
 
   def blobs_defined: List[(Document.Node.Name, SHA1.Digest)] =
     for (Exn.Res(blob) <- blobs; (digest, _) <- blob.content) yield (blob.name, digest)
 
   def blobs_changed(doc_blobs: Document.Blobs): Boolean =
     blobs.exists({ case Exn.Res(blob) => doc_blobs.changed(blob.name) case _ => false })
 
 
   /* source chunks */
 
   val chunk: Symbol.Text_Chunk = Symbol.Text_Chunk(source)
 
   val chunks: Map[Symbol.Text_Chunk.Name, Symbol.Text_Chunk] =
     ((Symbol.Text_Chunk.Default -> chunk) ::
       (for (Exn.Res(blob) <- blobs; (_, file) <- blob.content)
         yield blob.chunk_file -> file)).toMap
 
   def length: Int = source.length
   def range: Text.Range = chunk.range
 
   val core_range: Text.Range =
     Text.Range(0,
       (length /: span.content.reverse.iterator.takeWhile(_.is_ignored))(_ - _.source.length))
 
   def source(range: Text.Range): String = range.substring(source)
 
 
   /* theory parents */
 
   def theory_parents(resources: Resources): List[Document.Node.Name] =
     if (span.name == Thy_Header.THEORY) {
       try {
         val header = Thy_Header.read(node_name, span.content_reader)
         for ((s, _) <- header.imports)
         yield {
           try { resources.import_name(node_name, s) }
           catch { case ERROR(_) => Document.Node.Name.empty }
         }
       }
       catch { case ERROR(_) => Nil }
     }
     else Nil
 
 
   /* reported positions */
 
   def reported_position(pos: Position.T)
     : Option[(Document_ID.Generic, Symbol.Text_Chunk.Name, Option[Symbol.Range])] =
   {
     pos match {
       case Position.Id(id) =>
         val chunk_name =
           pos match {
             case Position.File(name) if name != node_name.node =>
               Symbol.Text_Chunk.File(name)
             case _ => Symbol.Text_Chunk.Default
           }
         Some((id, chunk_name, Position.Range.unapply(pos)))
       case _ => None
     }
   }
 
   def message_positions(
     self_id: Document_ID.Generic => Boolean,
     chunk_name: Symbol.Text_Chunk.Name,
     chunk: Symbol.Text_Chunk,
     message: XML.Elem): Set[Text.Range] =
   {
     def elem(props: Properties.T, set: Set[Text.Range]): Set[Text.Range] =
       reported_position(props) match {
         case Some((id, name, reported_range)) if self_id(id) && name == chunk_name =>
           val opt_range =
             reported_range orElse {
               if (name == Symbol.Text_Chunk.Default)
                 Position.Range.unapply(span.position)
               else None
             }
           opt_range match {
             case Some(symbol_range) =>
               chunk.incorporate(symbol_range) match {
                 case Some(range) => set + range
                 case _ => set
               }
             case None => set
           }
         case _ => set
       }
     def tree(set: Set[Text.Range], t: XML.Tree): Set[Text.Range] =
       t match {
         case XML.Wrapped_Elem(Markup(name, props), _, body) =>
           body.foldLeft(if (Rendering.position_elements(name)) elem(props, set) else set)(tree)
         case XML.Elem(Markup(name, props), body) =>
           body.foldLeft(if (Rendering.position_elements(name)) elem(props, set) else set)(tree)
         case XML.Text(_) => set
       }
 
     val set = tree(Set.empty, message)
     if (set.isEmpty) elem(message.markup.properties, set)
     else set
   }
 
 
   /* accumulated results */
 
   val init_state: Command.State =
     Command.State(this, results = init_results, markups = init_markups)
 
   val empty_state: Command.State = Command.State(this)
 }
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)
       {
         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); this }
+      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)
+        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))
+      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))
+      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))
+      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/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)
       {
         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)))
+        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)
     {
       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])
     {
       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])
     {
       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/line.scala b/src/Pure/PIDE/line.scala
--- a/src/Pure/PIDE/line.scala
+++ b/src/Pure/PIDE/line.scala
@@ -1,253 +1,253 @@
 /*  Title:      Pure/PIDE/line.scala
     Author:     Makarius
 
 Line-oriented text documents, with some bias towards VSCode.
 */
 
 package isabelle
 
 
 import scala.annotation.tailrec
 
 
 object Line
 {
   /* logical lines */
 
   def normalize(text: String): String =
     if (text.contains('\r')) text.replace("\r\n", "\n") else text
 
   def logical_lines(text: String): List[String] =
     split_lines(normalize(text))
 
 
   /* position */
 
   object Position
   {
     val zero: Position = Position()
     val offside: Position = Position(line = -1)
 
     object Ordering extends scala.math.Ordering[Position]
     {
       def compare(p1: Position, p2: Position): Int = p1 compare p2
     }
   }
 
   sealed case class Position(line: Int = 0, column: Int = 0)
   {
     def line1: Int = line + 1
     def column1: Int = column + 1
     def print: String = line1.toString + ":" + column1.toString
 
     def compare(that: Position): Int =
       line compare that.line match {
         case 0 => column compare that.column
         case i => i
       }
 
     def advance(text: String): Position =
       if (text.isEmpty) this
       else {
         val lines = logical_lines(text)
         val l = line + lines.length - 1
         val c = (if (l == line) column else 0) + Library.trim_line(lines.last).length
         Position(l, c)
       }
   }
 
 
   /* range (right-open interval) */
 
   object Range
   {
     def apply(start: Position): Range = Range(start, start)
     val zero: Range = Range(Position.zero)
   }
 
   sealed case class Range(start: Position, stop: Position)
   {
     if (start.compare(stop) > 0)
       error("Bad line range: " + start.print + ".." + stop.print)
 
     def print: String =
       if (start == stop) start.print
       else start.print + ".." + stop.print
   }
 
 
   /* positions within document node */
 
   object Node_Position
   {
     def offside(name: String): Node_Position = Node_Position(name, Position.offside)
   }
 
   sealed case class Node_Position(name: String, pos: Position = Position.zero)
   {
     def line: Int = pos.line
     def line1: Int = pos.line1
     def column: Int = pos.column
     def column1: Int = pos.column1
   }
 
   sealed case class Node_Range(name: String, range: Range = Range.zero)
   {
     def start: Position = range.start
     def stop: Position = range.stop
   }
 
 
   /* document with newline as separator (not terminator) */
 
   object Document
   {
     def apply(text: String): Document =
       Document(logical_lines(text).map(s => Line(Library.isolate_substring(s))))
 
     val empty: Document = apply("")
 
     private def split(line_text: String): List[Line] =
       if (line_text == "") List(Line.empty) else apply(line_text).lines
 
     private def chop(lines: List[Line]): (String, List[Line]) =
       lines match {
         case Nil => ("", Nil)
         case line :: rest => (line.text, rest)
       }
 
     private def length(lines: List[Line]): Int =
       if (lines.isEmpty) 0
       else ((0 /: lines) { case (n, line) => n + line.text.length + 1 }) - 1
 
     def text(lines: List[Line]): String = lines.mkString("", "\n", "")
   }
 
   sealed case class Document(lines: List[Line])
   {
     lazy val text_length: Text.Offset = Document.length(lines)
     def text_range: Text.Range = Text.Range(0, text_length)
 
     lazy val text: String = Document.text(lines)
 
     def get_text(range: Text.Range): Option[String] =
       if (text_range.contains(range)) Some(range.substring(text)) else None
 
     override def toString: String = text
 
     override def equals(that: Any): Boolean =
       that match {
         case other: Document => lines == other.lines
         case _ => false
       }
     override def hashCode(): Int = lines.hashCode
 
     def position(text_offset: Text.Offset): Position =
     {
       @tailrec def move(i: Text.Offset, lines_count: Int, lines_rest: List[Line]): Position =
       {
         lines_rest match {
-          case Nil => require(i == 0); Position(lines_count)
+          case Nil => require(i == 0, "bad Line.position.move"); Position(lines_count)
           case line :: ls =>
             val n = line.text.length
             if (ls.isEmpty || i <= n)
               Position(lines_count).advance(line.text.substring(n - i))
             else move(i - (n + 1), lines_count + 1, ls)
         }
       }
       move(text_offset, 0, lines)
     }
 
     def range(text_range: Text.Range): Range =
       Range(position(text_range.start), position(text_range.stop))
 
     def offset(pos: Position): Option[Text.Offset] =
     {
       val l = pos.line
       val c = pos.column
       val n = lines.length
       if (0 <= l && l < n) {
         if (0 <= c && c <= lines(l).text.length) {
           val line_offset =
             (0 /: lines.iterator.take(l)) { case (n, line) => n + line.text.length + 1 }
           Some(line_offset + c)
         }
         else None
       }
       else if (l == n && c == 0) Some(text_length)
       else None
     }
 
     def change(remove: Range, insert: String): Option[(List[Text.Edit], Document)] =
     {
       for {
         edit_start <- offset(remove.start)
         if remove.stop == remove.start || offset(remove.stop).isDefined
         l1 = remove.start.line
         l2 = remove.stop.line
         if l1 <= l2
         (removed_text, new_lines) <-
         {
           val c1 = remove.start.column
           val c2 = remove.stop.column
 
           val (prefix, lines1) = lines.splitAt(l1)
           val (s1, rest1) = Document.chop(lines1)
 
           if (l1 == l2) {
             if (0 <= c1 && c1 <= c2 && c2 <= s1.length) {
               Some(
                 if (lines1.isEmpty) ("", prefix ::: Document.split(insert))
                 else {
                   val removed_text = s1.substring(c1, c2)
                   val changed_text = s1.substring(0, c1) + insert + s1.substring(c2)
                   (removed_text, prefix ::: Document.split(changed_text) ::: rest1)
                 })
             }
             else None
           }
           else {
             val (middle, lines2) = rest1.splitAt(l2 - l1 - 1)
             val (s2, rest2) = Document.chop(lines2)
             if (0 <= c1 && c1 <= s1.length && 0 <= c2 && c2 <= s2.length) {
               Some(
                 if (lines1.isEmpty) ("", prefix ::: Document.split(insert))
                 else {
                   val r1 = s1.substring(c1)
                   val r2 = s2.substring(0, c2)
                   val removed_text =
                     if (lines2.isEmpty) Document.text(Line(r1) :: middle)
                     else Document.text(Line(r1) :: middle ::: List(Line(r2)))
                   val changed_text = s1.substring(0, c1) + insert + s2.substring(c2)
                   (removed_text, prefix ::: Document.split(changed_text) ::: rest2)
                 })
             }
             else None
           }
         }
       }
       yield
         (Text.Edit.removes(edit_start, removed_text) ::: Text.Edit.inserts(edit_start, insert),
           Document(new_lines))
     }
   }
 
 
   /* line text */
 
   val empty: Line = new Line("")
   def apply(text: String): Line = if (text == "") empty else new Line(text)
 }
 
 final class Line private(val text: String)
 {
-  require(text.forall(c => c != '\r' && c != '\n'))
+  require(text.forall(c => c != '\r' && c != '\n'), "bad line text")
 
   override def equals(that: Any): Boolean =
     that match {
       case other: Line => text == other.text
       case _ => false
     }
   override def hashCode(): Int = text.hashCode
   override def toString: String = text
 }
diff --git a/src/Pure/PIDE/markup_tree.scala b/src/Pure/PIDE/markup_tree.scala
--- a/src/Pure/PIDE/markup_tree.scala
+++ b/src/Pure/PIDE/markup_tree.scala
@@ -1,268 +1,268 @@
 /*  Title:      Pure/PIDE/markup_tree.scala
     Author:     Fabian Immler, TU Munich
     Author:     Makarius
 
 Markup trees over nested / non-overlapping text ranges.
 */
 
 package isabelle
 
 
 import scala.collection.immutable.SortedMap
 import scala.collection.mutable
 import scala.annotation.tailrec
 
 
 object Markup_Tree
 {
   /* construct trees */
 
   val empty: Markup_Tree = new Markup_Tree(Branches.empty)
 
   def merge(trees: List[Markup_Tree], range: Text.Range, elements: Markup.Elements): Markup_Tree =
     (empty /: trees)(_.merge(_, range, elements))
 
   def merge_disjoint(trees: List[Markup_Tree]): Markup_Tree =
     trees match {
       case Nil => empty
       case head :: tail =>
         new Markup_Tree(
           (head.branches /: tail) {
             case (branches, tree) =>
               (branches /: tree.branches) {
                 case (bs, (r, entry)) =>
-                  require(!bs.isDefinedAt(r))
+                  require(!bs.isDefinedAt(r), "cannot merge markup trees")
                   bs + (r -> entry)
               }
           })
     }
 
 
   /* tree building blocks */
 
   object Entry
   {
     def apply(markup: Text.Markup, subtree: Markup_Tree): Entry =
       Entry(markup.range, List(markup.info), subtree)
   }
 
   sealed case class Entry(
     range: Text.Range,
     rev_markup: List[XML.Elem],
     subtree: Markup_Tree)
   {
     def markup: List[XML.Elem] = rev_markup.reverse
 
     def filter_markup(elements: Markup.Elements): List[XML.Elem] =
     {
       var result: List[XML.Elem] = Nil
       for (elem <- rev_markup if elements(elem.name))
         result ::= elem
       result
     }
 
     def + (markup: Text.Markup): Entry = copy(rev_markup = markup.info :: rev_markup)
     def \ (markup: Text.Markup): Entry = copy(subtree = subtree + markup)
   }
 
   object Branches
   {
     type T = SortedMap[Text.Range, Entry]
     val empty: T = SortedMap.empty(Text.Range.Ordering)
   }
 
 
   /* XML representation */
 
   @tailrec private def strip_elems(
       elems: List[XML.Elem], body: XML.Body): (List[XML.Elem], XML.Body) =
     body match {
       case List(XML.Wrapped_Elem(markup1, body1, body2)) =>
         strip_elems(XML.Elem(markup1, body1) :: elems, body2)
       case List(XML.Elem(markup1, body1)) =>
         strip_elems(XML.Elem(markup1, Nil) :: elems, body1)
       case _ => (elems, body)
     }
 
   private def make_trees(acc: (Int, List[Markup_Tree]), tree: XML.Tree): (Int, List[Markup_Tree]) =
     {
       val (offset, markup_trees) = acc
 
       strip_elems(Nil, List(tree)) match {
         case (Nil, body) =>
           (offset + XML.text_length(body), markup_trees)
 
         case (elems, body) =>
           val (end_offset, subtrees) = ((offset, Nil: List[Markup_Tree]) /: body)(make_trees)
           if (offset == end_offset) acc
           else {
             val range = Text.Range(offset, end_offset)
             val entry = Entry(range, elems, merge_disjoint(subtrees))
             (end_offset, new Markup_Tree(Branches.empty, entry) :: markup_trees)
           }
       }
     }
 
   def from_XML(body: XML.Body): Markup_Tree =
     merge_disjoint(((0, Nil: List[Markup_Tree]) /: body)(make_trees)._2)
 }
 
 
 final class Markup_Tree private(val branches: Markup_Tree.Branches.T)
 {
   import Markup_Tree._
 
   private def this(branches: Markup_Tree.Branches.T, entry: Markup_Tree.Entry) =
     this(branches + (entry.range -> entry))
 
   private def overlapping(range: Text.Range): Branches.T =
     if (branches.isEmpty ||
         (range.contains(branches.firstKey.start) && branches.lastKey.stop <= range.stop))
       branches
     else {
       val start = Text.Range(range.start)
       val stop = Text.Range(range.stop)
       val bs = branches.range(start, stop)
       branches.get(stop) match {
         case Some(end) if range overlaps end.range => bs + (end.range -> end)
         case _ => bs
       }
     }
 
   def restrict(range: Text.Range): Markup_Tree =
     new Markup_Tree(overlapping(range))
 
   def is_empty: Boolean = branches.isEmpty
 
   def + (new_markup: Text.Markup): Markup_Tree =
   {
     val new_range = new_markup.range
 
     branches.get(new_range) match {
       case None => new Markup_Tree(branches, Entry(new_markup, empty))
       case Some(entry) =>
         if (entry.range == new_range)
           new Markup_Tree(branches, entry + new_markup)
         else if (entry.range.contains(new_range))
           new Markup_Tree(branches, entry \ new_markup)
         else if (new_range.contains(branches.head._1) && new_range.contains(branches.last._1))
           new Markup_Tree(Branches.empty, Entry(new_markup, this))
         else {
           val body = overlapping(new_range)
           if (body.forall(e => new_range.contains(e._1)))
             new Markup_Tree(branches -- body.keys, Entry(new_markup, new Markup_Tree(body)))
           else {
             Output.warning("Ignored overlapping markup information: " + new_markup + "\n" +
               body.filter(e => !new_range.contains(e._1)).values.mkString("\n"))
             this
           }
         }
     }
   }
 
   def merge(other: Markup_Tree, root_range: Text.Range, elements: Markup.Elements): Markup_Tree =
   {
     def merge_trees(tree1: Markup_Tree, tree2: Markup_Tree): Markup_Tree =
       (tree1 /: tree2.branches)(
         { case (tree, (range, entry)) =>
             if (!range.overlaps(root_range)) tree
             else
               (merge_trees(tree, entry.subtree) /: entry.filter_markup(elements))(
                 { case (t, elem) => t + Text.Info(range, elem) })
         })
 
     if (this eq other) this
     else {
       val tree1 = this.restrict(root_range)
       val tree2 = other.restrict(root_range)
       if (tree1.is_empty) tree2
       else merge_trees(tree1, tree2)
     }
   }
 
   def cumulate[A](root_range: Text.Range, root_info: A, elements: Markup.Elements,
     result: (A, Text.Markup) => Option[A]): List[Text.Info[A]] =
   {
     def results(x: A, entry: Entry): Option[A] =
     {
       var y = x
       var changed = false
       for {
         elem <- entry.filter_markup(elements)
         y1 <- result(y, Text.Info(entry.range, elem))
       } { y = y1; changed = true }
       if (changed) Some(y) else None
     }
 
     def traverse(
       last: Text.Offset,
       stack: List[(Text.Info[A], List[(Text.Range, Entry)])]): List[Text.Info[A]] =
     {
       stack match {
         case (parent, (range, entry) :: more) :: rest =>
           val subrange = range.restrict(root_range)
           val subtree = entry.subtree.overlapping(subrange).toList
           val start = subrange.start
 
           results(parent.info, entry) match {
             case Some(res) =>
               val next = Text.Info(subrange, res)
               val nexts = traverse(start, (next, subtree) :: (parent, more) :: rest)
               if (last < start) parent.restrict(Text.Range(last, start)) :: nexts
               else nexts
             case None => traverse(last, (parent, subtree ::: more) :: rest)
           }
 
         case (parent, Nil) :: rest =>
           val stop = parent.range.stop
           val nexts = traverse(stop, rest)
           if (last < stop) parent.restrict(Text.Range(last, stop)) :: nexts
           else nexts
 
         case Nil =>
           val stop = root_range.stop
           if (last < stop) List(Text.Info(Text.Range(last, stop), root_info))
           else Nil
       }
     }
     traverse(root_range.start,
       List((Text.Info(root_range, root_info), overlapping(root_range).toList)))
   }
 
   def to_XML(root_range: Text.Range, text: CharSequence, elements: Markup.Elements): XML.Body =
   {
     def make_text(start: Text.Offset, stop: Text.Offset): XML.Body =
       if (start == stop) Nil
       else List(XML.Text(text.subSequence(start, stop).toString))
 
     def make_elems(rev_markups: List[XML.Elem], body: XML.Body): XML.Body =
       (body /: rev_markups) {
         case (b, elem) =>
           if (!elements(elem.name)) b
           else if (elem.body.isEmpty) List(XML.Elem(elem.markup, b))
           else List(XML.Wrapped_Elem(elem.markup, elem.body, b))
       }
 
     def make_body(elem_range: Text.Range, elem_markup: List[XML.Elem], entries: Branches.T)
       : XML.Body =
     {
       val body = new mutable.ListBuffer[XML.Tree]
       var last = elem_range.start
       for ((range, entry) <- entries) {
         val subrange = range.restrict(elem_range)
         body ++= make_text(last, subrange.start)
         body ++= make_body(subrange, entry.rev_markup, entry.subtree.overlapping(subrange))
         last = subrange.stop
       }
       body ++= make_text(last, elem_range.stop)
       make_elems(elem_markup, body.toList)
     }
    make_body(root_range, Nil, overlapping(root_range))
   }
 
   override def toString: String =
     branches.toList.map(_._2) match {
       case Nil => "Empty"
       case list => list.mkString("Tree(", ",", ")")
     }
 }
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,776 @@
 /*  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 post(a: A)
     {
       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)
+    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()
     {
       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()
     {
       delay.revoke()
       state.change(_ => None)
     }
 
     def update(new_nodes: Set[Document.Node.Name] = Set.empty)
     {
       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 }) }
   }
 
 
   /* 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)
     //{{{
     {
-      require(prover.defined)
+      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)
     //{{{
     {
-      require(prover.defined)
+      require(prover.defined, "prover process not defined (handle_change)")
 
       // define commands
       {
         val id_commands = new mutable.ListBuffer[Command]
         def id_command(command: Command)
         {
           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 bad_output()
       {
         if (verbose)
           Output.warning("Ignoring bad prover output: " + output.message.toString)
       }
 
       def change_command(f: Document.State => (Command.State, Document.State))
       {
         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)
   {
     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 update(doc_blobs: Document.Blobs, edits: List[Document.Edit_Text])
   {
     if (edits.nonEmpty) manager.send_wait(Session.Raw_Edits(doc_blobs, edits))
   }
 
   def update_options(options: Options)
   { manager.send_wait(Update_Options(options)) }
 
   def dialog_result(id: Document_ID.Generic, serial: Long, result: String)
   { manager.send(Session.Dialog_Result(id, serial, result)) }
 }
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)
   {
-    require(Platform.is_windows)
+    require(Platform.is_windows, "Windows platform expected")
 
     def exec(cmdline: String*)
     {
       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)
   {
     val target_path = target.toPath
 
     using(Files.newBufferedWriter(target_path, UTF8.charset))(
       _.write("!<symlink>" + content + "\u0000"))
 
     Files.setAttribute(target_path, "dos:system", true)
   }
 }
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,159 @@
 /*  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)
   {
-    require(!description.contains(','))
+    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_shutdown(name: String)
   {
     try { service_stop(name) }
     catch { case ERROR(_) => }
   }
 
   def service_install(name: String, spec: String)
   {
     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)
+    require(length >= 6, "password too short")
     Isabelle_System.bash("pwgen " + length + " 1").check.out
   }
 }
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,701 +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)
     {
       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 @<Scan for and process a \.{.bib} command or database entry@>.
 
   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)
+        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) {
         File.copy(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)) + ")")
         }
       File.copy(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("<!-- BEGIN BIBLIOGRAPHY")).reverse.
             dropWhile(line => !line.startsWith("<!-- END BIBLIOGRAPHY")).reverse)
       }
       else html
     })
   }
 }
diff --git a/src/Pure/Thy/presentation.scala b/src/Pure/Thy/presentation.scala
--- a/src/Pure/Thy/presentation.scala
+++ b/src/Pure/Thy/presentation.scala
@@ -1,769 +1,769 @@
 /*  Title:      Pure/Thy/present.scala
     Author:     Makarius
 
 HTML/PDF presentation of theory documents.
 */
 
 package isabelle
 
 
 import scala.collection.immutable.SortedMap
 
 
 object Presentation
 {
   /** HTML documents **/
 
   val fonts_path = Path.explode("fonts")
 
   sealed case class HTML_Document(title: String, content: String)
 
   def html_context(fonts_url: String => String = HTML.fonts_url()): HTML_Context =
     new HTML_Context(fonts_url)
 
   final class HTML_Context private[Presentation](fonts_url: String => String)
   {
     def init_fonts(dir: Path)
     {
       val fonts_dir = Isabelle_System.make_directory(dir + fonts_path)
       for (entry <- Isabelle_Fonts.fonts(hidden = true))
         File.copy(entry.path, fonts_dir)
     }
 
     def head(title: String, rest: XML.Body = Nil): XML.Tree =
       HTML.div("head", HTML.chapter(title) :: rest)
 
     def source(body: XML.Body): XML.Tree = HTML.pre("source", body)
 
     def contents(heading: String, items: List[XML.Body], css_class: String = "contents")
       : List[XML.Elem] =
     {
       if (items.isEmpty) Nil
       else List(HTML.div(css_class, List(HTML.section(heading), HTML.itemize(items))))
     }
 
     def output_document(title: String, body: XML.Body): String =
       HTML.output_document(
         List(
           HTML.style(HTML.fonts_css(fonts_url) + "\n\n" + File.read(HTML.isabelle_css)),
           HTML.title(title)),
         List(HTML.source(body)), css = "", structural = false)
 
     def html_document(title: String, body: XML.Body): HTML_Document =
       HTML_Document(title, output_document(title, body))
   }
 
 
   /* presentation elements */
 
   sealed case class Elements(
     html: Markup.Elements = Markup.Elements.empty,
     entity: Markup.Elements = Markup.Elements.empty,
     language: Markup.Elements = Markup.Elements.empty)
 
   val elements1: Elements =
     Elements(
       html =
         Rendering.foreground_elements ++ Rendering.text_color_elements +
         Markup.NUMERAL + Markup.COMMENT + Markup.ENTITY + Markup.LANGUAGE,
       entity = Markup.Elements(Markup.THEORY))
 
   val elements2: Elements =
     Elements(
       html = elements1.html ++ Rendering.markdown_elements,
       language = Markup.Elements(Markup.Language.DOCUMENT))
 
 
   /* HTML */
 
   private val div_elements =
     Set(HTML.div.name, HTML.pre.name, HTML.par.name, HTML.list.name, HTML.enum.name,
       HTML.descr.name)
 
   def make_html(
     elements: Elements,
     entity_link: (Properties.T, XML.Body) => Option[XML.Tree],
     xml: XML.Body): XML.Body =
   {
     def html_div(html: XML.Body): Boolean =
       html exists {
         case XML.Elem(markup, body) => div_elements.contains(markup.name) || html_div(body)
         case XML.Text(_) => false
       }
 
     def html_class(c: String, html: XML.Body): XML.Body =
       if (c == "") html
       else if (html_div(html)) List(HTML.div(c, html))
       else List(HTML.span(c, html))
 
     def html_body(xml_body: XML.Body): XML.Body =
       xml_body flatMap {
         case XML.Wrapped_Elem(markup, _, body) => html_body(List(XML.Elem(markup, body)))
         case XML.Elem(Markup(Markup.ENTITY, props @ Markup.Kind(kind)), body) =>
           val body1 = html_body(body)
           if (elements.entity(kind)) {
             entity_link(props, body1) match {
               case Some(link) => List(link)
               case None => body1
             }
           }
           else body1
         case XML.Elem(Markup(Markup.LANGUAGE, Markup.Name(name)), body) =>
           html_class(if (elements.language(name)) name else "", html_body(body))
         case XML.Elem(Markup(Markup.MARKDOWN_PARAGRAPH, _), body) =>
           List(HTML.par(html_body(body)))
         case XML.Elem(Markup(Markup.MARKDOWN_ITEM, _), body) =>
           List(HTML.item(html_body(body)))
         case XML.Elem(Markup(Markup.Markdown_Bullet.name, _), _) => Nil
         case XML.Elem(Markup.Markdown_List(kind), body) =>
           if (kind == Markup.ENUMERATE) List(HTML.enum(html_body(body)))
           else List(HTML.list(html_body(body)))
         case XML.Elem(markup, body) =>
           val name = markup.name
           val html =
             markup.properties match {
               case Markup.Kind(kind) if kind == Markup.COMMAND || kind == Markup.KEYWORD =>
                 html_class(kind, html_body(body))
               case _ =>
                 html_body(body)
             }
           Rendering.foreground.get(name) orElse Rendering.text_color.get(name) match {
             case Some(c) => html_class(c.toString, html)
             case None => html_class(name, html)
           }
         case XML.Text(text) =>
           HTML.text(Symbol.decode(text))
       }
 
     html_body(xml)
   }
 
 
   /* PIDE HTML document */
 
   def html_document(
     resources: Resources,
     snapshot: Document.Snapshot,
     html_context: HTML_Context,
     elements: Elements,
     plain_text: Boolean = false): HTML_Document =
   {
-    require(!snapshot.is_outdated)
+    require(!snapshot.is_outdated, "document snapshot outdated")
 
     val name = snapshot.node_name
     if (plain_text) {
       val title = "File " + Symbol.cartouche_decoded(name.path.file_name)
       val body = HTML.text(snapshot.node.source)
       html_context.html_document(title, body)
     }
     else {
       resources.html_document(snapshot) getOrElse {
         val title =
           if (name.is_theory) "Theory " + quote(name.theory_base_name)
           else "File " + Symbol.cartouche_decoded(name.path.file_name)
         val body = make_html(elements, (_, _) => None, snapshot.xml_markup(elements = elements.html))
         html_context.html_document(title, body)
       }
     }
   }
 
 
 
   /** PDF LaTeX documents **/
 
   /* document info */
 
   abstract class Document_Name
   {
     def name: String
     def path: Path = Path.basic(name)
 
     override def toString: String = name
   }
 
   object Document_Variant
   {
     def parse(name: String, tags: String): Document_Variant =
       Document_Variant(name, Library.space_explode(',', tags))
 
     def parse(opt: String): Document_Variant =
       Library.space_explode('=', opt) match {
         case List(name) => Document_Variant(name, Nil)
         case List(name, tags) => parse(name, tags)
         case _ => error("Malformed document variant: " + quote(opt))
       }
   }
 
   sealed case class Document_Variant(name: String, tags: List[String]) extends Document_Name
   {
     def print_tags: String = tags.mkString(",")
     def print: String = if (tags.isEmpty) name else name + "=" + print_tags
 
     def latex_sty: String =
       Library.terminate_lines(
         tags.map(tag =>
           tag.toList match {
             case '/' :: cs => "\\isafoldtag{" + cs.mkString + "}"
             case '-' :: cs => "\\isadroptag{" + cs.mkString + "}"
             case '+' :: cs => "\\isakeeptag{" + cs.mkString + "}"
             case cs => "\\isakeeptag{" + cs.mkString + "}"
           }))
   }
 
   sealed case class Document_Input(name: String, sources: SHA1.Digest)
     extends Document_Name
 
   sealed case class Document_Output(name: String, sources: SHA1.Digest, log_xz: Bytes, pdf: Bytes)
     extends Document_Name
   {
     def log: String = log_xz.uncompress().text
     def log_lines: List[String] = split_lines(log)
 
     def write(db: SQL.Database, session_name: String): Unit =
       write_document(db, session_name, this)
   }
 
 
   /* SQL data model */
 
   object Data
   {
     val session_name = SQL.Column.string("session_name").make_primary_key
     val name = SQL.Column.string("name").make_primary_key
     val sources = SQL.Column.string("sources")
     val log_xz = SQL.Column.bytes("log_xz")
     val pdf = SQL.Column.bytes("pdf")
 
     val table = SQL.Table("isabelle_documents", List(session_name, name, sources, log_xz, pdf))
 
     def where_equal(session_name: String, name: String = ""): SQL.Source =
       "WHERE " + Data.session_name.equal(session_name) +
         (if (name == "") "" else " AND " + Data.name.equal(name))
   }
 
   def read_documents(db: SQL.Database, session_name: String): List[Document_Input] =
   {
     val select = Data.table.select(List(Data.name, Data.sources), Data.where_equal(session_name))
     db.using_statement(select)(stmt =>
       stmt.execute_query().iterator(res =>
       {
         val name = res.string(Data.name)
         val sources = res.string(Data.sources)
         Document_Input(name, SHA1.fake(sources))
       }).toList)
   }
 
   def read_document(db: SQL.Database, session_name: String, name: String): Option[Document_Output] =
   {
     val select = Data.table.select(sql = Data.where_equal(session_name, name))
     db.using_statement(select)(stmt =>
     {
       val res = stmt.execute_query()
       if (res.next()) {
         val name = res.string(Data.name)
         val sources = res.string(Data.sources)
         val log_xz = res.bytes(Data.log_xz)
         val pdf = res.bytes(Data.pdf)
         Some(Document_Output(name, SHA1.fake(sources), log_xz, pdf))
       }
       else None
     })
   }
 
   def write_document(db: SQL.Database, session_name: String, doc: Document_Output)
   {
     db.using_statement(Data.table.insert())(stmt =>
     {
       stmt.string(1) = session_name
       stmt.string(2) = doc.name
       stmt.string(3) = doc.sources.toString
       stmt.bytes(4) = doc.log_xz
       stmt.bytes(5) = doc.pdf
       stmt.execute()
     })
   }
 
 
   /* presentation context */
 
   object Context
   {
     val none: Context = new Context { def enabled: Boolean = false }
     val standard: Context = new Context { def enabled: Boolean = true }
 
     def dir(path: Path): Context =
       new Context {
         def enabled: Boolean = true
         override def dir(store: Sessions.Store): Path = path
       }
 
     def make(s: String): Context =
       if (s == ":") standard else dir(Path.explode(s))
   }
 
   abstract class Context private
   {
     def enabled: Boolean
     def enabled(info: Sessions.Info): Boolean = enabled || info.browser_info
     def dir(store: Sessions.Store): Path = store.presentation_dir
     def dir(store: Sessions.Store, info: Sessions.Info): Path =
       dir(store) + Path.explode(info.chapter_session)
   }
 
 
 
   /** HTML presentation **/
 
   /* maintain chapter index */
 
   private val sessions_path = Path.basic(".sessions")
 
   private def read_sessions(dir: Path): List[(String, String)] =
   {
     val path = dir + sessions_path
     if (path.is_file) {
       import XML.Decode._
       list(pair(string, string))(Symbol.decode_yxml(File.read(path)))
     }
     else Nil
   }
 
   private def write_sessions(dir: Path, sessions: List[(String, String)])
   {
     import XML.Encode._
     File.write(dir + sessions_path, YXML.string_of_body(list(pair(string, string))(sessions)))
   }
 
   def update_chapter_index(browser_info: Path, chapter: String, new_sessions: List[(String, String)])
   {
     val dir = Isabelle_System.make_directory(browser_info + Path.basic(chapter))
 
     val sessions0 =
       try { read_sessions(dir) }
       catch { case _: XML.Error => Nil }
 
     val sessions = (SortedMap.empty[String, String] ++ sessions0 ++ new_sessions).toList
     write_sessions(dir, sessions)
 
     val title = "Isabelle/" + chapter + " sessions"
     HTML.write_document(dir, "index.html",
       List(HTML.title(title + " (" + Distribution.version + ")")),
       HTML.chapter(title) ::
        (if (sessions.isEmpty) Nil
         else
           List(HTML.div("sessions",
             List(HTML.description(
               sessions.map({ case (name, description) =>
                 val descr = Symbol.trim_blank_lines(description)
                 (List(HTML.link(name + "/index.html", HTML.text(name))),
                   if (descr == "") Nil
                   else HTML.break ::: List(HTML.pre(HTML.text(descr)))) })))))))
   }
 
   def make_global_index(browser_info: Path)
   {
     if (!(browser_info + Path.explode("index.html")).is_file) {
       Isabelle_System.make_directory(browser_info)
       File.copy(Path.explode("~~/lib/logo/isabelle.gif"),
         browser_info + Path.explode("isabelle.gif"))
       File.write(browser_info + Path.explode("index.html"),
         File.read(Path.explode("~~/lib/html/library_index_header.template")) +
         File.read(Path.explode("~~/lib/html/library_index_content.template")) +
         File.read(Path.explode("~~/lib/html/library_index_footer.template")))
     }
   }
 
 
   /* present session */
 
   val session_graph_path = Path.explode("session_graph.pdf")
   val readme_path = Path.explode("README.html")
   val files_path = Path.explode("files")
 
   def html_name(name: Document.Node.Name): String = name.theory_base_name + ".html"
 
   def theory_link(deps: Sessions.Deps, session0: String,
     name: Document.Node.Name, body: XML.Body): Option[XML.Tree] =
   {
     val session1 = deps(session0).theory_qualifier(name)
     val info0 = deps.sessions_structure.get(session0)
     val info1 = deps.sessions_structure.get(session1)
     if (info0.isDefined && info1.isDefined) {
       Some(HTML.link(info0.get.relative_path(info1.get) + html_name(name), body))
     }
     else None
   }
 
   def session_html(
     resources: Resources,
     session: String,
     deps: Sessions.Deps,
     db_context: Sessions.Database_Context,
     progress: Progress = new Progress,
     verbose: Boolean = false,
     html_context: HTML_Context,
     elements: Elements,
     presentation: Context)
   {
     val info = deps.sessions_structure(session)
     val options = info.options
     val base = deps(session)
 
     val session_dir = presentation.dir(db_context.store, info)
 
     html_context.init_fonts(session_dir)
 
     Bytes.write(session_dir + session_graph_path,
       graphview.Graph_File.make_pdf(options, base.session_graph_display))
 
     val documents =
       for {
         doc <- info.document_variants
         document <- db_context.input_database(session)(read_document(_, _, doc.name))
       } yield {
         if (verbose) progress.echo("Presenting document " + session + "/" + doc.name)
         Bytes.write(session_dir + doc.path.pdf, document.pdf)
         doc
       }
 
     val view_links =
     {
       val deps_link =
         HTML.link(session_graph_path, HTML.text("theory dependencies"))
 
       val readme_links =
         if ((info.dir + readme_path).is_file) {
           File.copy(info.dir + readme_path, session_dir + readme_path)
           List(HTML.link(readme_path, HTML.text("README")))
         }
         else Nil
 
       val document_links =
         documents.map(doc => HTML.link(doc.path.pdf, HTML.text(doc.name)))
 
       Library.separate(HTML.break ::: HTML.nl,
         (deps_link :: readme_links ::: document_links).
           map(link => HTML.text("View ") ::: List(link))).flatten
     }
 
     val theories: List[XML.Body] =
     {
       var seen_files = List.empty[(Path, String, Document.Node.Name)]
 
       def entity_link(props: Properties.T, body: XML.Body): Option[XML.Tree] =
         (props, props, props) match {
           case (Markup.Kind(Markup.THEORY), Markup.Name(theory), Position.Def_File(thy_file)) =>
             val node_name = resources.file_node(Path.explode(thy_file), theory = theory)
             theory_link(deps, session, node_name, body)
           case _ => None
         }
 
       for {
         thy_name <- base.session_theories
         thy_command <- Build_Job.read_theory(db_context, resources, session, thy_name.theory)
       }
       yield {
         progress.expose_interrupt()
         if (verbose) progress.echo("Presenting theory " + thy_name)
 
         val snapshot = Document.State.init.snippet(thy_command)
 
         val files =
           for {
             (src_path, xml) <- snapshot.xml_markup_blobs(elements = elements.html)
             if xml.nonEmpty
           }
           yield {
             progress.expose_interrupt()
             if (verbose) progress.echo("Presenting file " + src_path)
 
             val file_name = (files_path + src_path.squash.html).implode
 
             seen_files.find(p => p._1 == src_path || p._2 == file_name) match {
               case None => seen_files ::= (src_path, file_name, thy_name)
               case Some((_, _, thy_name1)) =>
                 error("Incoherent use of file name " + src_path + " as " + quote(file_name) +
                   " in theory " + thy_name1 + " vs. " + thy_name)
             }
 
             val file_path = session_dir + Path.explode(file_name)
             html_context.init_fonts(file_path.dir)
 
             val file_title = "File " + Symbol.cartouche_decoded(src_path.implode_short)
             HTML.write_document(file_path.dir, file_path.file_name,
               List(HTML.title(file_title)),
               List(html_context.head(file_title),
                 html_context.source(make_html(elements, entity_link, xml))))
 
             List(HTML.link(file_name, HTML.text(file_title)))
           }
 
         val thy_title = "Theory " + thy_name.theory_base_name
         val thy_body = make_html(elements, entity_link, snapshot.xml_markup(elements = elements.html))
         HTML.write_document(session_dir, html_name(thy_name),
           List(HTML.title(thy_title)),
           List(html_context.head(thy_title), html_context.source(thy_body)))
 
         List(HTML.link(html_name(thy_name),
           HTML.text(thy_name.theory_base_name) :::
             (if (files.isEmpty) Nil else List(HTML.itemize(files)))))
       }
     }
 
     val title = "Session " + session
     HTML.write_document(session_dir, "index.html",
       List(HTML.title(title + " (" + Distribution.version + ")")),
       html_context.head(title, List(HTML.par(view_links))) ::
         html_context.contents("Theories", theories))
   }
 
 
 
   /** build documents **/
 
   val session_tex_path = Path.explode("session.tex")
 
   def tex_name(name: Document.Node.Name): String = name.theory_base_name + ".tex"
   def document_tex_name(name: Document.Node.Name): String = "document/" + tex_name(name)
 
   class Build_Error(val log_lines: List[String], val message: String)
     extends Exn.User_Error(message)
 
   def build_documents(
     session: String,
     deps: Sessions.Deps,
     db_context: Sessions.Database_Context,
     progress: Progress = new Progress,
     output_sources: Option[Path] = None,
     output_pdf: Option[Path] = None,
     verbose: Boolean = false,
     verbose_latex: Boolean = false): List[Document_Output] =
   {
     /* session info */
 
     val info = deps.sessions_structure(session)
     val hierarchy = deps.sessions_structure.hierarchy(session)
     val options = info.options
     val base = deps(session)
     val graph_pdf = graphview.Graph_File.make_pdf(options, base.session_graph_display)
 
 
     /* prepare document directory */
 
     lazy val tex_files =
       for (name <- base.session_theories ::: base.document_theories)
       yield {
         val entry = db_context.get_export(hierarchy, name.theory, document_tex_name(name))
         Path.basic(tex_name(name)) -> entry.uncompressed
       }
 
     def prepare_dir1(dir: Path, doc: Document_Variant): (Path, String) =
     {
       val doc_dir = dir + Path.basic(doc.name)
       Isabelle_System.make_directory(doc_dir)
 
       Isabelle_System.bash("isabelle latex -o sty", cwd = doc_dir.file).check
       File.write(doc_dir + Path.explode("isabelletags.sty"), doc.latex_sty)
       for ((base_dir, src) <- info.document_files) File.copy_base(info.dir + base_dir, src, doc_dir)
 
       File.write(doc_dir + session_tex_path,
         Library.terminate_lines(
           base.session_theories.map(name => "\\input{" + tex_name(name) + "}")))
 
       for ((path, tex) <- tex_files) Bytes.write(doc_dir + path, tex)
 
       val root1 = "root_" + doc.name
       val root = if ((doc_dir + Path.explode(root1).tex).is_file) root1 else "root"
 
       (doc_dir, root)
     }
 
     def prepare_dir2(dir: Path, doc: Document_Variant): Unit =
     {
       val doc_dir = dir + Path.basic(doc.name)
 
       // non-deterministic, but irrelevant
       Bytes.write(doc_dir + session_graph_path, graph_pdf)
     }
 
 
     /* produce documents */
 
     val documents =
       for (doc <- info.documents)
       yield {
         Isabelle_System.with_tmp_dir("document")(tmp_dir =>
         {
           progress.echo("Preparing " + session + "/" + doc.name + " ...")
           val start = Time.now()
 
 
           // prepare sources
 
           val (doc_dir, root) = prepare_dir1(tmp_dir, doc)
           val digests = File.find_files(doc_dir.file, follow_links = true).map(SHA1.digest)
           val sources = SHA1.digest_set(digests)
           prepare_dir2(tmp_dir, doc)
 
           for (dir <- output_sources) {
             prepare_dir1(dir, doc)
             prepare_dir2(dir, doc)
           }
 
 
           // old document from database
 
           val old_document =
             for {
               old_doc <- db_context.input_database(session)(read_document(_, _, doc.name))
               if old_doc.sources == sources
             }
             yield {
               Bytes.write(doc_dir + doc.path.pdf, old_doc.pdf)
               old_doc
             }
 
           old_document getOrElse {
             // bash scripts
 
             def root_bash(ext: String): String = Bash.string(root + "." + ext)
 
             def latex_bash(fmt: String = "pdf", ext: String = "tex"): String =
               "isabelle latex -o " + Bash.string(fmt) + " " + Bash.string(root + "." + ext)
 
             def bash(items: String*): Process_Result =
               progress.bash(items.mkString(" && "), cwd = doc_dir.file,
                 echo = verbose_latex, watchdog = Time.seconds(0.5))
 
 
             // prepare document
 
             val result =
               if ((doc_dir + Path.explode("build")).is_file) {
                 bash("./build pdf " + Bash.string(doc.name))
               }
               else {
                 bash(
                   latex_bash(),
                   "{ [ ! -f " + root_bash("bib") + " ] || " + latex_bash("bbl") + "; }",
                   "{ [ ! -f " + root_bash("idx") + " ] || " + latex_bash("idx") + "; }",
                   latex_bash(),
                   latex_bash())
               }
 
 
             // result
 
             val root_pdf = Path.basic(root).pdf
             val result_path = doc_dir + root_pdf
 
             val log_lines = result.out_lines ::: result.err_lines
 
             if (!result.ok) {
               val message =
                 Exn.cat_message(
                   Library.trim_line(result.err),
                   cat_lines(Latex.latex_errors(doc_dir, root) ::: Bibtex.bibtex_errors(doc_dir, root)),
                   "Failed to build document " + quote(doc.name))
               throw new Build_Error(log_lines, message)
             }
             else if (!result_path.is_file) {
               val message = "Bad document result: expected to find " + root_pdf
               throw new Build_Error(log_lines, message)
             }
             else {
               val stop = Time.now()
               val timing = stop - start
               progress.echo("Finished " + session + "/" + doc.name +
                 " (" + timing.message_hms + " elapsed time)")
 
               val log_xz = Bytes(cat_lines(log_lines)).compress()
               val pdf = Bytes.read(result_path)
               Document_Output(doc.name, sources, log_xz, pdf)
             }
           }
         })
       }
 
     for (dir <- output_pdf; doc <- documents) {
       Isabelle_System.make_directory(dir)
       val path = dir + doc.path.pdf
       Bytes.write(path, doc.pdf)
       progress.echo("Document at " + path.absolute)
     }
 
     documents
   }
 
 
   /* Isabelle tool wrapper */
 
   val isabelle_tool =
     Isabelle_Tool("document", "prepare session theory document", Scala_Project.here, args =>
     {
       var output_sources: Option[Path] = None
       var output_pdf: Option[Path] = None
       var verbose_latex = false
       var dirs: List[Path] = Nil
       var options = Options.init()
       var verbose_build = false
 
       val getopts = Getopts(
         """
 Usage: isabelle document [OPTIONS] SESSION
 
   Options are:
     -O DIR       output directory for LaTeX sources and resulting PDF
     -P DIR       output directory for resulting PDF
     -S DIR       output directory for LaTeX sources
     -V           verbose latex
     -d DIR       include session directory
     -o OPTION    override Isabelle system OPTION (via NAME=VAL or NAME)
     -v           verbose build
 
   Prepare the theory document of a session.
 """,
         "O:" -> (arg =>
           {
             val dir = Path.explode(arg)
             output_sources = Some(dir)
             output_pdf = Some(dir)
           }),
         "P:" -> (arg => { output_pdf = Some(Path.explode(arg)) }),
         "S:" -> (arg => { output_sources = Some(Path.explode(arg)) }),
         "V" -> (_ => verbose_latex = true),
         "d:" -> (arg => dirs = dirs ::: List(Path.explode(arg))),
         "o:" -> (arg => options = options + arg),
         "v" -> (_ => verbose_build = true))
 
       val more_args = getopts(args)
       val session =
         more_args match {
           case List(a) => a
           case _ => getopts.usage()
         }
 
       val progress = new Console_Progress(verbose = verbose_build)
       val store = Sessions.store(options)
 
       progress.interrupt_handler {
         val res =
           Build.build(options, selection = Sessions.Selection.session(session),
             dirs = dirs, progress = progress, verbose = verbose_build)
         if (!res.ok) error("Failed to build session " + quote(session))
 
         val deps =
           Sessions.load_structure(options + "document=pdf", dirs = dirs).
             selection_deps(Sessions.Selection.session(session))
 
         if (output_sources.isEmpty && output_pdf.isEmpty) {
           progress.echo_warning("No output directory")
         }
 
         using(store.open_database_context())(db_context =>
           build_documents(session, deps, db_context, progress = progress,
             output_sources = output_sources, output_pdf = output_pdf,
             verbose = true, verbose_latex = verbose_latex))
       }
     })
 }
diff --git a/src/Pure/Thy/thy_syntax.scala b/src/Pure/Thy/thy_syntax.scala
--- a/src/Pure/Thy/thy_syntax.scala
+++ b/src/Pure/Thy/thy_syntax.scala
@@ -1,362 +1,362 @@
 /*  Title:      Pure/Thy/thy_syntax.scala
     Author:     Makarius
 
 Superficial theory syntax: tokens and spans.
 */
 
 package isabelle
 
 
 import scala.collection.mutable
 import scala.annotation.tailrec
 
 
 object Thy_Syntax
 {
   /** perspective **/
 
   def command_perspective(
       node: Document.Node,
       perspective: Text.Perspective,
       overlays: Document.Node.Overlays): (Command.Perspective, Command.Perspective) =
   {
     if (perspective.is_empty && overlays.is_empty)
       (Command.Perspective.empty, Command.Perspective.empty)
     else {
       val has_overlay = overlays.commands
       val visible = new mutable.ListBuffer[Command]
       val visible_overlay = new mutable.ListBuffer[Command]
       @tailrec
       def check_ranges(ranges: List[Text.Range], commands: Stream[(Command, Text.Offset)])
       {
         (ranges, commands) match {
           case (range :: more_ranges, (command, offset) #:: more_commands) =>
             val command_range = command.range + offset
             range compare command_range match {
               case 0 =>
                 visible += command
                 visible_overlay += command
                 check_ranges(ranges, more_commands)
               case c =>
                 if (has_overlay(command)) visible_overlay += command
 
                 if (c < 0) check_ranges(more_ranges, commands)
                 else check_ranges(ranges, more_commands)
             }
 
           case (Nil, (command, _) #:: more_commands) =>
             if (has_overlay(command)) visible_overlay += command
 
             check_ranges(Nil, more_commands)
 
           case _ =>
         }
       }
 
       val commands =
         (if (overlays.is_empty) node.command_iterator(perspective.range)
          else node.command_iterator()).toStream
       check_ranges(perspective.ranges, commands)
       (Command.Perspective(visible.toList), Command.Perspective(visible_overlay.toList))
     }
   }
 
 
 
   /** header edits: graph structure and outer syntax **/
 
   private def header_edits(
     resources: Resources,
     previous: Document.Version,
     edits: List[Document.Edit_Text]):
     (List[Document.Node.Name], Document.Nodes, List[Document.Edit_Command]) =
   {
     val syntax_changed0 = new mutable.ListBuffer[Document.Node.Name]
     var nodes = previous.nodes
     val doc_edits = new mutable.ListBuffer[Document.Edit_Command]
 
     edits foreach {
       case (name, Document.Node.Deps(header)) =>
         val node = nodes(name)
         val update_header =
           node.header.errors.nonEmpty || header.errors.nonEmpty || node.header != header
         if (update_header) {
           val node1 = node.update_header(header)
           if (node.header.imports != node1.header.imports ||
               node.header.keywords != node1.header.keywords ||
               node.header.abbrevs != node1.header.abbrevs ||
               node.header.errors != node1.header.errors) syntax_changed0 += name
           nodes += (name -> node1)
           doc_edits += (name -> Document.Node.Deps(header))
         }
       case _ =>
     }
 
     val syntax_changed = nodes.descendants(syntax_changed0.toList)
 
     for (name <- syntax_changed) {
       val node = nodes(name)
       val syntax =
         if (node.is_empty) None
         else {
           val header = node.header
           val imports_syntax =
             if (header.imports.nonEmpty) {
               Outer_Syntax.merge(header.imports.map(resources.session_base.node_syntax(nodes, _)))
             }
             else resources.session_base.overall_syntax
           Some(imports_syntax + header)
         }
       nodes += (name -> node.update_syntax(syntax))
     }
 
     (syntax_changed, nodes, doc_edits.toList)
   }
 
 
 
   /** text edits **/
 
   /* edit individual command source */
 
   @tailrec def edit_text(eds: List[Text.Edit], commands: Linear_Set[Command]): Linear_Set[Command] =
   {
     eds match {
       case e :: es =>
         def insert_text(cmd: Option[Command], text: String): Linear_Set[Command] =
           if (text == "") commands else commands.insert_after(cmd, Command.text(text))
 
         Document.Node.Commands.starts(commands.iterator).find {
           case (cmd, cmd_start) =>
             e.can_edit(cmd.source, cmd_start) ||
               e.is_insert && e.start == cmd_start + cmd.length
         } match {
           case Some((cmd, cmd_start)) if e.can_edit(cmd.source, cmd_start) =>
             val (rest, text) = e.edit(cmd.source, cmd_start)
             val new_commands = insert_text(Some(cmd), text) - cmd
             edit_text(rest.toList ::: es, new_commands)
 
           case Some((cmd, _)) =>
             edit_text(es, insert_text(Some(cmd), e.text))
 
           case None =>
-            require(e.is_insert && e.start == 0)
+            require(e.is_insert && e.start == 0, "bad text edit")
             edit_text(es, insert_text(None, e.text))
         }
       case Nil => commands
     }
   }
 
 
   /* reparse range of command spans */
 
   @tailrec private def chop_common(
       cmds: List[Command],
       blobs_spans: List[(Command.Blobs_Info, Command_Span.Span)])
     : (List[Command], List[(Command.Blobs_Info, Command_Span.Span)]) =
   {
     (cmds, blobs_spans) match {
       case (cmd :: cmds, (blobs_info, span) :: rest)
       if cmd.blobs_info == blobs_info && cmd.span == span => chop_common(cmds, rest)
       case _ => (cmds, blobs_spans)
     }
   }
 
   private def reparse_spans(
     resources: Resources,
     syntax: Outer_Syntax,
     get_blob: Document.Node.Name => Option[Document.Blob],
     can_import: Document.Node.Name => Boolean,
     node_name: Document.Node.Name,
     commands: Linear_Set[Command],
     first: Command, last: Command): Linear_Set[Command] =
   {
     val cmds0 = commands.iterator(first, last).toList
     val blobs_spans0 =
       syntax.parse_spans(cmds0.iterator.map(_.source).mkString).map(span =>
         (Command.blobs_info(resources, syntax, get_blob, can_import, node_name, span), span))
 
     val (cmds1, blobs_spans1) = chop_common(cmds0, blobs_spans0)
 
     val (rev_cmds2, rev_blobs_spans2) = chop_common(cmds1.reverse, blobs_spans1.reverse)
     val cmds2 = rev_cmds2.reverse
     val blobs_spans2 = rev_blobs_spans2.reverse
 
     cmds2 match {
       case Nil =>
         assert(blobs_spans2.isEmpty)
         commands
       case cmd :: _ =>
         val hook = commands.prev(cmd)
         val inserted =
           blobs_spans2.map({ case (blobs, span) =>
             Command(Document_ID.make(), node_name, blobs, span) })
         (commands /: cmds2)(_ - _).append_after(hook, inserted)
     }
   }
 
 
   /* main */
 
   def diff_commands(old_cmds: Linear_Set[Command], new_cmds: Linear_Set[Command])
     : List[Command.Edit] =
   {
     val removed = old_cmds.iterator.filter(!new_cmds.contains(_)).toList
     val inserted = new_cmds.iterator.filter(!old_cmds.contains(_)).toList
 
     removed.map(cmd => (old_cmds.prev(cmd), None)) reverse_:::
     inserted.map(cmd => (new_cmds.prev(cmd), Some(cmd)))
   }
 
   private def text_edit(
     resources: Resources,
     syntax: Outer_Syntax,
     get_blob: Document.Node.Name => Option[Document.Blob],
     can_import: Document.Node.Name => Boolean,
     reparse_limit: Int,
     node: Document.Node, edit: Document.Edit_Text): Document.Node =
   {
     /* recover command spans after edits */
     // FIXME somewhat slow
     def recover_spans(
       name: Document.Node.Name,
       perspective: Command.Perspective,
       commands: Linear_Set[Command]): Linear_Set[Command] =
     {
       val is_visible = perspective.commands.toSet
 
       def next_invisible(cmds: Linear_Set[Command], from: Command): Command =
         cmds.iterator(from).dropWhile(cmd => !cmd.is_proper || is_visible(cmd))
           .find(_.is_proper) getOrElse cmds.last
 
       @tailrec def recover(cmds: Linear_Set[Command]): Linear_Set[Command] =
         cmds.find(_.is_unparsed) match {
           case Some(first_unparsed) =>
             val first = next_invisible(cmds.reverse, first_unparsed)
             val last = next_invisible(cmds, first_unparsed)
             recover(
               reparse_spans(resources, syntax, get_blob, can_import, name, cmds, first, last))
           case None => cmds
         }
       recover(commands)
     }
 
     edit match {
       case (_, Document.Node.Blob(blob)) => node.init_blob(blob)
 
       case (name, Document.Node.Edits(text_edits)) =>
         if (name.is_theory) {
           val commands0 = node.commands
           val commands1 = edit_text(text_edits, commands0)
           val commands2 = recover_spans(name, node.perspective.visible, commands1)
           node.update_commands(commands2)
         }
         else node
 
       case (_, Document.Node.Deps(_)) => node
 
       case (name, Document.Node.Perspective(required, text_perspective, overlays)) =>
         val (visible, visible_overlay) = command_perspective(node, text_perspective, overlays)
         val perspective: Document.Node.Perspective_Command =
           Document.Node.Perspective(required, visible_overlay, overlays)
         if (node.same_perspective(text_perspective, perspective)) node
         else {
           /* consolidate unfinished spans */
           val is_visible = visible.commands.toSet
           val commands = node.commands
           val commands1 =
             if (is_visible.isEmpty) commands
             else {
               commands.find(_.is_unfinished) match {
                 case Some(first_unfinished) =>
                   commands.reverse.find(is_visible) match {
                     case Some(last_visible) =>
                       val it = commands.iterator(last_visible)
                       var last = last_visible
                       var i = 0
                       while (i < reparse_limit && it.hasNext) {
                         last = it.next
                         i += last.length
                       }
                       reparse_spans(resources, syntax, get_blob, can_import,
                         name, commands, first_unfinished, last)
                     case None => commands
                   }
                 case None => commands
               }
             }
           node.update_perspective(text_perspective, perspective).update_commands(commands1)
         }
     }
   }
 
   def parse_change(
       resources: Resources,
       reparse_limit: Int,
       previous: Document.Version,
       doc_blobs: Document.Blobs,
       edits: List[Document.Edit_Text],
       consolidate: List[Document.Node.Name]): Session.Change =
   {
     val (syntax_changed, nodes0, doc_edits0) = header_edits(resources, previous, edits)
 
     def get_blob(name: Document.Node.Name): Option[Document.Blob] =
       doc_blobs.get(name) orElse previous.nodes(name).get_blob
 
     def can_import(name: Document.Node.Name): Boolean =
       resources.session_base.loaded_theory(name) || nodes0(name).has_header
 
     val (doc_edits, version) =
       if (edits.isEmpty) (Nil, Document.Version.make(previous.nodes))
       else {
         val reparse =
           (syntax_changed /: nodes0.iterator)({
             case (reparse, (name, node)) =>
               if (node.load_commands_changed(doc_blobs) && !reparse.contains(name))
                 name :: reparse
               else reparse
             })
         val reparse_set = reparse.toSet
 
         var nodes = nodes0
         val doc_edits = new mutable.ListBuffer[Document.Edit_Command]; doc_edits ++= doc_edits0
 
         val node_edits =
           (edits ::: reparse.map((_, Document.Node.Edits(Nil)))).groupBy(_._1)
             .asInstanceOf[Map[Document.Node.Name, List[Document.Edit_Text]]]  // FIXME ???
 
         node_edits foreach {
           case (name, edits) =>
             val node = nodes(name)
             val syntax = resources.session_base.node_syntax(nodes, name)
             val commands = node.commands
 
             val node1 =
               if (reparse_set(name) && commands.nonEmpty)
                 node.update_commands(
                   reparse_spans(resources, syntax, get_blob, can_import, name,
                     commands, commands.head, commands.last))
               else node
             val node2 =
               (node1 /: edits)(
                 text_edit(resources, syntax, get_blob, can_import, reparse_limit, _, _))
             val node3 =
               if (reparse_set.contains(name))
                 text_edit(resources, syntax, get_blob, can_import, reparse_limit,
                   node2, (name, node2.edit_perspective))
               else node2
 
             if (!node.same_perspective(node3.text_perspective, node3.perspective))
               doc_edits += (name -> node3.perspective)
 
             doc_edits += (name -> Document.Node.Edits(diff_commands(commands, node3.commands)))
 
             nodes += (name -> node3)
         }
         (doc_edits.toList.filterNot(_._2.is_void), Document.Version.make(nodes))
       }
 
     Session.Change(
       previous, syntax_changed, syntax_changed.nonEmpty, doc_edits, consolidate, version)
   }
 }
diff --git a/src/Pure/Tools/phabricator.scala b/src/Pure/Tools/phabricator.scala
--- a/src/Pure/Tools/phabricator.scala
+++ b/src/Pure/Tools/phabricator.scala
@@ -1,1084 +1,1084 @@
 /*  Title:      Pure/Tools/phabricator.scala
     Author:     Makarius
 
 Support for Phabricator server, notably for Ubuntu 18.04 LTS.
 
 See also:
   - https://www.phacility.com/phabricator
   - https://secure.phabricator.com/book/phabricator
 */
 
 package isabelle
 
 
 import scala.collection.mutable
 import scala.util.matching.Regex
 
 
 object Phabricator
 {
   /** defaults **/
 
   /* required packages */
 
   val packages_ubuntu_18_04: List[String] =
     Build_Docker.packages :::
     List(
       // https://secure.phabricator.com/source/phabricator/browse/master/scripts/install/install_ubuntu.sh 15e6e2adea61
       "git", "mysql-server", "apache2", "libapache2-mod-php", "php", "php-mysql",
       "php-gd", "php-curl", "php-apcu", "php-cli", "php-json", "php-mbstring",
       // more packages
       "php-xml", "php-zip", "python-pygments", "ssh", "subversion", "python-pygments",
       // mercurial build packages
       "make", "gcc", "python", "python-dev", "python-docutils", "python-openssl")
 
   val packages_ubuntu_20_04: List[String] =
     packages_ubuntu_18_04.map(
       {
         case "python-pygments" => "python3-pygments"
         case "python-dev" => "python2-dev"
         case name => name
       })
 
   def packages: List[String] =
   {
     val release = Linux.Release()
     if (release.is_ubuntu_18_04) packages_ubuntu_18_04
     else if (release.is_ubuntu_20_04) packages_ubuntu_20_04
     else error("Bad Linux version: expected Ubuntu 18.04 or 20.04 LTS")
   }
 
 
   /* global system resources */
 
   val www_user = "www-data"
 
   val daemon_user = "phabricator"
 
   val sshd_config: Path = Path.explode("/etc/ssh/sshd_config")
 
 
   /* installation parameters */
 
   val default_name = "vcs"
 
   def phabricator_name(name: String = "", ext: String = ""): String =
     "phabricator" + (if (name.isEmpty) "" else "-" + name) + (if (ext.isEmpty) "" else "." + ext)
 
   def isabelle_phabricator_name(name: String = "", ext: String = ""): String =
     "isabelle-" + phabricator_name(name = name, ext = ext)
 
   def default_root(name: String): Path =
     Path.explode("/var/www") + Path.basic(phabricator_name(name = name))
 
   def default_repo(name: String): Path = default_root(name) + Path.basic("repo")
 
   val default_mailers: Path = Path.explode("mailers.json")
 
   val default_system_port: Int = SSH.default_port
   val alternative_system_port = 222
   val default_server_port = 2222
 
   val standard_mercurial_source = "https://www.mercurial-scm.org/release/mercurial-3.9.2.tar.gz"
 
 
 
   /** global configuration **/
 
   val global_config: Path = Path.explode("/etc/" + isabelle_phabricator_name(ext = "conf"))
 
   def global_config_script(
     init: String = "",
     body: String = "",
     exit: String = ""): String =
   {
 """#!/bin/bash
 """ + (if (init.nonEmpty) "\n" + init else "") + """
 {
   while { unset REPLY; read -r; test "$?" = 0 -o -n "$REPLY"; }
   do
     NAME="$(echo "$REPLY" | cut -d: -f1)"
     ROOT="$(echo "$REPLY" | cut -d: -f2)"
     {
 """ + Library.prefix_lines("      ", body) + """
     } < /dev/null
   done
 } < """ + File.bash_path(global_config) + "\n" +
     (if (exit.nonEmpty) "\n" + exit + "\n" else "")
   }
 
   sealed case class Config(name: String, root: Path)
   {
     def home: Path = root + Path.explode(phabricator_name())
 
     def execute(command: String): Process_Result =
       Isabelle_System.bash("bin/" + command, cwd = home.file, redirect = true).check
   }
 
   def read_config(): List[Config] =
   {
     if (global_config.is_file) {
       for (entry <- Library.trim_split_lines(File.read(global_config)) if entry.nonEmpty)
       yield {
         space_explode(':', entry) match {
           case List(name, root) => Config(name, Path.explode(root))
           case _ => error("Malformed config file " + global_config + "\nentry " + quote(entry))
         }
       }
     }
     else Nil
   }
 
   def write_config(configs: List[Config])
   {
     File.write(global_config,
       configs.map(config => config.name + ":" + config.root.implode).mkString("", "\n", "\n"))
   }
 
   def get_config(name: String): Config =
     read_config().find(config => config.name == name) getOrElse
       error("Bad Isabelle/Phabricator installation " + quote(name))
 
 
 
   /** administrative tools **/
 
   /* Isabelle tool wrapper */
 
   val isabelle_tool1 =
     Isabelle_Tool("phabricator", "invoke command-line tool within Phabricator home directory",
       Scala_Project.here, args =>
     {
       var list = false
       var name = default_name
 
       val getopts =
         Getopts("""
 Usage: isabelle phabricator [OPTIONS] COMMAND [ARGS...]
 
   Options are:
     -l           list available Phabricator installations
     -n NAME      Phabricator installation name (default: """ + quote(default_name) + """)
 
   Invoke a command-line tool within the home directory of the named
   Phabricator installation.
 """,
           "l" -> (_ => list = true),
           "n:" -> (arg => name = arg))
 
       val more_args = getopts(args)
       if (more_args.isEmpty && !list) getopts.usage()
 
       val progress = new Console_Progress
 
       if (list) {
         for (config <- read_config()) {
           progress.echo("phabricator " + quote(config.name) + " root " + config.root)
         }
       }
       else {
         val config = get_config(name)
         val result = progress.bash(Bash.strings(more_args), cwd = config.home.file, echo = true)
         if (!result.ok) error(result.print_return_code)
       }
     })
 
 
 
   /** setup **/
 
   def user_setup(name: String, description: String, ssh_setup: Boolean = false)
   {
     if (!Linux.user_exists(name)) {
       Linux.user_add(name, description = description, system = true, ssh_setup = ssh_setup)
     }
     else if (Linux.user_description(name) != description) {
       error("User " + quote(name) + " already exists --" +
         " for Phabricator it should have the description:\n  " + quote(description))
     }
   }
 
   def command_setup(name: String,
     init: String = "",
     body: String = "",
     exit: String = ""): Path =
   {
     val command = Path.explode("/usr/local/bin") + Path.basic(name)
     File.write(command, global_config_script(init = init, body = body, exit = exit))
     Isabelle_System.chmod("755", command)
     Isabelle_System.chown("root:root", command)
     command
   }
 
   def mercurial_setup(mercurial_source: String, progress: Progress = new Progress)
   {
     progress.echo("\nMercurial installation from source " + quote(mercurial_source) + " ...")
     Isabelle_System.with_tmp_dir("mercurial")(tmp_dir =>
     {
       val archive =
         if (Url.is_wellformed(mercurial_source)) {
           val archive = tmp_dir + Path.basic("mercurial.tar.gz")
           Bytes.write(archive, Url.read_bytes(Url(mercurial_source)))
           archive
         }
         else Path.explode(mercurial_source)
 
       Isabelle_System.gnutar("-xzf " + File.bash_path(archive), dir = tmp_dir).check
       val build_dir = tmp_dir + Path.basic(File.get_dir(tmp_dir))
 
       progress.bash("make all && make install", cwd = build_dir.file, echo = true).check
     })
   }
 
   def phabricator_setup(
     options: Options,
     name: String = default_name,
     root: String = "",
     repo: String = "",
     package_update: Boolean = false,
     mercurial_source: String = "",
     progress: Progress = new Progress)
   {
     /* system environment */
 
     Linux.check_system_root()
 
     progress.echo("System packages ...")
 
     if (package_update) {
       Linux.package_update(progress = progress)
       Linux.check_reboot_required()
     }
 
     Linux.package_install(packages, progress = progress)
     Linux.check_reboot_required()
 
 
     if (mercurial_source.nonEmpty) {
       for { name <- List("mercurial", "mercurial-common") if Linux.package_installed(name) } {
         error("Cannot install Mercurial from source:\n" +
           "package package " + quote(name) + " already installed")
       }
       mercurial_setup(mercurial_source, progress = progress)
     }
 
 
     /* users */
 
     if (name.exists((c: Char) => !(Symbol.is_ascii_letter(c) || Symbol.is_ascii_digit(c))) ||
         Set("", "ssh", "phd", "dump", daemon_user).contains(name)) {
       error("Bad installation name: " + quote(name))
     }
 
     user_setup(daemon_user, "Phabricator Daemon User", ssh_setup = true)
     user_setup(name, "Phabricator SSH User")
 
 
     /* basic installation */
 
     progress.echo("\nPhabricator installation ...")
 
     val root_path = if (root.nonEmpty) Path.explode(root) else default_root(name)
     val repo_path = if (repo.nonEmpty) Path.explode(repo) else default_repo(name)
 
     val configs = read_config()
 
     for (config <- configs if config.name == name) {
       error("Duplicate Phabricator installation " + quote(name) + " in " + config.root)
     }
 
     if (!Isabelle_System.bash("mkdir -p " + File.bash_path(root_path)).ok) {
       error("Failed to create root directory " + root_path)
     }
 
     Isabelle_System.chown(Bash.string(www_user) + ":" + Bash.string(www_user), root_path)
     Isabelle_System.chmod("755", root_path)
 
     progress.bash(cwd = root_path.file, echo = true,
       script = """
         set -e
         echo "Cloning distribution repositories:"
 
         git clone --branch stable https://github.com/phacility/arcanist.git
         git -C arcanist reset --hard """ +
           Bash.string(options.string("phabricator_version_arcanist")) + """
 
         git clone --branch stable https://github.com/phacility/phabricator.git
         git -C phabricator reset --hard """ +
           Bash.string(options.string("phabricator_version_phabricator")) + """
       """).check
 
     val config = Config(name, root_path)
     write_config(configs ::: List(config))
 
     config.execute("config set pygments.enabled true")
 
 
     /* local repository directory */
 
     progress.echo("\nRepository hosting setup ...")
 
     if (!Isabelle_System.bash("mkdir -p " + File.bash_path(repo_path)).ok) {
       error("Failed to create local repository directory " + repo_path)
     }
 
     Isabelle_System.chown(
       "-R " + Bash.string(daemon_user) + ":" + Bash.string(daemon_user), repo_path)
     Isabelle_System.chmod("755", repo_path)
 
     config.execute("config set repository.default-local-path " + File.bash_path(repo_path))
 
 
     val sudoers_file =
       Path.explode("/etc/sudoers.d") + Path.basic(isabelle_phabricator_name(name = name))
     File.write(sudoers_file,
       www_user + " ALL=(" + daemon_user + ") SETENV: NOPASSWD: /usr/bin/git, /usr/local/bin/hg, /usr/bin/hg, /usr/bin/ssh, /usr/bin/id\n" +
       name + " ALL=(" + daemon_user + ") SETENV: NOPASSWD: /usr/bin/git, /usr/bin/git-upload-pack, /usr/bin/git-receive-pack, /usr/local/bin/hg, /usr/bin/hg, /usr/bin/svnserve, /usr/bin/ssh, /usr/bin/id\n")
 
     Isabelle_System.chmod("440", sudoers_file)
 
     config.execute("config set diffusion.ssh-user " + Bash.string(config.name))
 
 
     /* MySQL setup */
 
     progress.echo("\nMySQL setup ...")
 
     File.write(Path.explode("/etc/mysql/mysql.conf.d/" + phabricator_name(ext = "cnf")),
 """[mysqld]
 max_allowed_packet = 32M
 innodb_buffer_pool_size = 1600M
 local_infile = 0
 """)
 
     Linux.service_restart("mysql")
 
 
     def mysql_conf(R: Regex, which: String): String =
     {
       val conf = Path.explode("/etc/mysql/debian.cnf")
       split_lines(File.read(conf)).collectFirst({ case R(a) => a }) match {
         case Some(res) => res
         case None => error("Cannot determine " + which + " from " + conf)
       }
     }
 
     val mysql_root_user = mysql_conf("""^user\s*=\s*(\S*)\s*$""".r, "superuser name")
     val mysql_root_password = mysql_conf("""^password\s*=\s*(\S*)\s*$""".r, "superuser password")
 
     val mysql_name = phabricator_name(name = name).replace("-", "_")
     val mysql_user_string = SQL.string(mysql_name) + "@'localhost'"
     val mysql_password = Linux.generate_password()
 
     Isabelle_System.bash("mysql --user=" + Bash.string(mysql_root_user) +
       " --password=" + Bash.string(mysql_root_password) + " --execute=" +
       Bash.string(
         """DROP USER IF EXISTS """ + mysql_user_string + "; " +
         """CREATE USER """ + mysql_user_string +
         """ IDENTIFIED BY """ + SQL.string(mysql_password) + """ PASSWORD EXPIRE NEVER; """ +
         """GRANT ALL ON `""" + (mysql_name + "_%").replace("_", "\\_") +
         """`.* TO """ + mysql_user_string + ";" +
         """GRANT PROCESS ON *.* TO """ + mysql_user_string + ";")).check
 
     config.execute("config set mysql.user " + Bash.string(mysql_name))
     config.execute("config set mysql.pass " + Bash.string(mysql_password))
 
     config.execute("config set phabricator.cache-namespace " + Bash.string(mysql_name))
     config.execute("config set storage.default-namespace " + Bash.string(mysql_name))
     config.execute("config set storage.mysql-engine.max-size 8388608")
 
     progress.bash("bin/storage upgrade --force", cwd = config.home.file, echo = true).check
 
 
     /* database dump */
 
     val dump_name = isabelle_phabricator_name(name = "dump")
     command_setup(dump_name, body =
 """mkdir -p "$ROOT/database" && chown root:root "$ROOT/database" && chmod 700 "$ROOT/database"
 [ -e "$ROOT/database/dump.sql.gz" ] && mv -f "$ROOT/database/dump.sql.gz" "$ROOT/database/dump-old.sql.gz"
 echo -n "Creating $ROOT/database/dump.sql.gz ..."
 "$ROOT/phabricator/bin/storage" dump --compress --output "$ROOT/database/dump.sql.gz" 2>&1 | fgrep -v '[Warning] Using a password on the command line interface can be insecure'
 echo " $(ls -hs "$ROOT/database/dump.sql.gz" | cut -d" " -f1)" """)
 
 
     /* Phabricator upgrade */
 
     command_setup(isabelle_phabricator_name(name = "upgrade"),
       init =
 """BRANCH="${1:-stable}"
 if [ "$BRANCH" != "master" -a "$BRANCH" != "stable" ]
 then
   echo "Bad branch: \"$BRANCH\""
   exit 1
 fi
 
 systemctl stop isabelle-phabricator-phd
 systemctl stop apache2
 """,
       body =
 """echo -e "\nUpgrading phabricator \"$NAME\" root \"$ROOT\" ..."
 for REPO in arcanist phabricator
 do
   cd "$ROOT/$REPO"
   echo -e "\nUpdating \"$REPO\" ..."
   git checkout "$BRANCH"
   git pull
 done
 echo -e "\nUpgrading storage ..."
 "$ROOT/phabricator/bin/storage" upgrade --force
 """,
       exit =
 """systemctl start apache2
 systemctl start isabelle-phabricator-phd""")
 
 
     /* PHP setup */
 
     val php_version =
       Isabelle_System.bash("""php --run 'echo PHP_MAJOR_VERSION . "." . PHP_MINOR_VERSION;'""")
         .check.out
 
     val php_conf =
       Path.explode("/etc/php") + Path.basic(php_version) +  // educated guess
         Path.explode("apache2/conf.d") +
         Path.basic(isabelle_phabricator_name(ext = "ini"))
 
     File.write(php_conf,
       "post_max_size = 32M\n" +
       "opcache.validate_timestamps = 0\n" +
       "memory_limit = 512M\n" +
       "max_execution_time = 120\n")
 
 
     /* Apache setup */
 
     progress.echo("Apache setup ...")
 
     val apache_root = Path.explode("/etc/apache2")
     val apache_sites = apache_root + Path.explode("sites-available")
 
     if (!apache_sites.is_dir) error("Bad Apache sites directory " + apache_sites)
 
     val server_name = phabricator_name(name = name, ext = "lvh.me")  // alias for "localhost" for testing
     val server_url = "http://" + server_name
 
     File.write(apache_sites + Path.basic(isabelle_phabricator_name(name = name, ext = "conf")),
 """<VirtualHost *:80>
     ServerName """ + server_name + """
     ServerAdmin webmaster@localhost
     DocumentRoot """ + config.home.implode + """/webroot
 
     ErrorLog ${APACHE_LOG_DIR}/error.log
     CustomLog ${APACHE_LOG_DIR}/access.log combined
 
     RewriteEngine on
     RewriteRule ^(.*)$  /index.php?__path__=$1  [B,L,QSA]
 </VirtualHost>
 
 # vim: syntax=apache ts=4 sw=4 sts=4 sr noet
 """)
 
     Isabelle_System.bash( """
       set -e
       a2enmod rewrite
       a2ensite """ + Bash.string(isabelle_phabricator_name(name = name))).check
 
     config.execute("config set phabricator.base-uri " + Bash.string(server_url))
 
     Linux.service_restart("apache2")
 
     progress.echo("\nFurther manual configuration via " + server_url)
 
 
     /* PHP daemon */
 
     progress.echo("\nPHP daemon setup ...")
 
     val phd_log_path = Isabelle_System.make_directory(Path.explode("/var/tmp/phd"))
     Isabelle_System.chown(
       "-R " + Bash.string(daemon_user) + ":" + Bash.string(daemon_user), phd_log_path)
     Isabelle_System.chmod("755", phd_log_path)
 
     config.execute("config set phd.user " + Bash.string(daemon_user))
     config.execute("config set phd.log-directory /var/tmp/phd/" +
       isabelle_phabricator_name(name = name) + "/log")
 
     val phd_name = isabelle_phabricator_name(name = "phd")
     Linux.service_shutdown(phd_name)
     val phd_command = command_setup(phd_name, body = """"$ROOT/phabricator/bin/phd" "$@" """)
     try {
       Linux.service_install(phd_name,
 """[Unit]
 Description=PHP daemon manager for Isabelle/Phabricator
 After=syslog.target network.target apache2.service mysql.service
 
 [Service]
 Type=oneshot
 User=""" + daemon_user + """
 Group=""" + daemon_user + """
 Environment=PATH=/sbin:/usr/sbin:/usr/local/sbin:/usr/local/bin:/usr/bin:/bin
 ExecStart=""" + phd_command.implode + """ start --force
 ExecStop=""" + phd_command.implode + """ stop
 RemainAfterExit=yes
 
 [Install]
 WantedBy=multi-user.target
 """)
     }
     catch {
       case ERROR(msg) =>
         progress.bash("bin/phd status", cwd = config.home.file, echo = true).check
         error(msg)
     }
   }
 
 
   /* Isabelle tool wrapper */
 
   val isabelle_tool2 =
     Isabelle_Tool("phabricator_setup", "setup Phabricator server on Ubuntu Linux",
       Scala_Project.here, args =>
     {
       var mercurial_source = ""
       var repo = ""
       var package_update = false
       var name = default_name
       var options = Options.init()
       var root = ""
 
       val getopts =
         Getopts("""
 Usage: isabelle phabricator_setup [OPTIONS]
 
   Options are:
     -M SOURCE    install Mercurial from source: local PATH, or URL, or ":" for
                  """ + standard_mercurial_source + """
     -R DIR       repository directory (default: """ + default_repo("NAME") + """)
     -U           full update of system packages before installation
     -n NAME      Phabricator installation name (default: """ + quote(default_name) + """)
     -o OPTION    override Isabelle system OPTION (via NAME=VAL or NAME)
     -r DIR       installation root directory (default: """ + default_root("NAME") + """)
 
   Install Phabricator as LAMP application (Linux, Apache, MySQL, PHP).
 
   The installation name (default: """ + quote(default_name) + """) is mapped to a regular
   Unix user; this is relevant for public SSH access.
 """,
           "M:" -> (arg => mercurial_source = (if (arg == ":") standard_mercurial_source else arg)),
           "R:" -> (arg => repo = arg),
           "U" -> (_ => package_update = true),
           "n:" -> (arg => name = arg),
           "o:" -> (arg => options = options + arg),
           "r:" -> (arg => root = arg))
 
       val more_args = getopts(args)
       if (more_args.nonEmpty) getopts.usage()
 
       val progress = new Console_Progress
 
       phabricator_setup(options, name = name, root = root, repo = repo,
         package_update = package_update, mercurial_source = mercurial_source, progress = progress)
     })
 
 
 
   /** setup mail **/
 
   val mailers_template: String =
 """[
   {
     "key": "example.org",
     "type": "smtp",
     "options": {
       "host": "mail.example.org",
       "port": 465,
       "user": "phabricator@example.org",
       "password": "********",
       "protocol": "ssl",
       "message-id": true
     }
   }
 ]"""
 
   def phabricator_setup_mail(
     name: String = default_name,
     config_file: Option[Path] = None,
     test_user: String = "",
     progress: Progress = new Progress)
   {
     Linux.check_system_root()
 
     val config = get_config(name)
     val default_config_file = config.root + default_mailers
 
     val mail_config = config_file getOrElse default_config_file
 
     def setup_mail
     {
       progress.echo("Using mail configuration from " + mail_config)
       config.execute("config set cluster.mailers --stdin < " + File.bash_path(mail_config))
 
       if (test_user.nonEmpty) {
         progress.echo("Sending test mail to " + quote(test_user))
         progress.bash(cwd = config.home.file, echo = true,
           script = """echo "Test from Phabricator ($(date))" | bin/mail send-test --subject "Test" --to """ +
             Bash.string(test_user)).check
       }
     }
 
     if (config_file.isEmpty) {
       if (!default_config_file.is_file) {
         File.write(default_config_file, mailers_template)
         Isabelle_System.chmod("600", default_config_file)
       }
       if (File.read(default_config_file) == mailers_template) {
         progress.echo("Please invoke the tool again, after providing details in\n  " +
           default_config_file.implode + "\n")
       }
       else setup_mail
     }
     else setup_mail
   }
 
 
   /* Isabelle tool wrapper */
 
   val isabelle_tool3 =
     Isabelle_Tool("phabricator_setup_mail", "setup mail for one Phabricator installation",
       Scala_Project.here, args =>
     {
       var test_user = ""
       var name = default_name
       var config_file: Option[Path] = None
 
       val getopts =
         Getopts("""
 Usage: isabelle phabricator_setup_mail [OPTIONS]
 
   Options are:
     -T USER      send test mail to Phabricator user
     -f FILE      config file (default: """ + default_mailers + """ within Phabricator root)
     -n NAME      Phabricator installation name (default: """ + quote(default_name) + """)
 
   Provide mail configuration for existing Phabricator installation.
 """,
           "T:" -> (arg => test_user = arg),
           "f:" -> (arg => config_file = Some(Path.explode(arg))),
           "n:" -> (arg => name = arg))
 
       val more_args = getopts(args)
       if (more_args.nonEmpty) getopts.usage()
 
       val progress = new Console_Progress
 
       phabricator_setup_mail(name = name, config_file = config_file,
         test_user = test_user, progress = progress)
     })
 
 
 
   /** setup ssh **/
 
   /* sshd config */
 
   private val Port = """^\s*Port\s+(\d+)\s*$""".r
   private val No_Port = """^#\s*Port\b.*$""".r
   private val Any_Port = """^#?\s*Port\b.*$""".r
 
   def conf_ssh_port(port: Int): String =
     if (port == SSH.default_port) "#Port " + SSH.default_port else "Port " + port
 
   def read_ssh_port(conf: Path): Int =
   {
     val lines = split_lines(File.read(conf))
     val ports =
       lines.flatMap({
         case Port(Value.Int(p)) => Some(p)
         case No_Port() => Some(SSH.default_port)
         case _ => None
       })
     ports match {
       case List(port) => port
       case Nil => error("Missing Port specification in " + conf)
       case _ => error("Multiple Port specifications in " + conf)
     }
   }
 
   def write_ssh_port(conf: Path, port: Int): Boolean =
   {
     val old_port = read_ssh_port(conf)
     if (old_port == port) false
     else {
       val lines = split_lines(File.read(conf))
       val lines1 = lines.map({ case Any_Port() => conf_ssh_port(port) case line => line })
       File.write(conf, cat_lines(lines1))
       true
     }
   }
 
 
   /* phabricator_setup_ssh */
 
   def phabricator_setup_ssh(
     server_port: Int = default_server_port,
     system_port: Int = default_system_port,
     progress: Progress = new Progress)
   {
     Linux.check_system_root()
 
     val configs = read_config()
 
     if (server_port == system_port) {
       error("Port for Phabricator sshd coincides with system port: " + system_port)
     }
 
     val sshd_conf_system = Path.explode("/etc/ssh/sshd_config")
     val sshd_conf_server = sshd_conf_system.ext(isabelle_phabricator_name())
 
     val ssh_name = isabelle_phabricator_name(name = "ssh")
     Linux.service_shutdown(ssh_name)
 
     val old_system_port = read_ssh_port(sshd_conf_system)
     if (old_system_port != system_port) {
       progress.echo("Reconfigurig system ssh service")
       Linux.service_shutdown("ssh")
       write_ssh_port(sshd_conf_system, system_port)
       Linux.service_start("ssh")
     }
 
     progress.echo("Configuring " + ssh_name + " service")
 
     val ssh_command = command_setup(ssh_name, body =
 """if [ "$1" = "$NAME" ]
 then
   exec "$ROOT/phabricator/bin/ssh-auth" "$@"
 fi""", exit = "exit 1")
 
     File.write(sshd_conf_server,
 """# OpenBSD Secure Shell server for Isabelle/Phabricator
 AuthorizedKeysCommand """ + ssh_command.implode + """
 AuthorizedKeysCommandUser """ + daemon_user + """
 AuthorizedKeysFile none
 AllowUsers """ + configs.map(_.name).mkString(" ") + """
 Port """ + server_port + """
 Protocol 2
 PermitRootLogin no
 AllowAgentForwarding no
 AllowTcpForwarding no
 PrintMotd no
 PrintLastLog no
 PasswordAuthentication no
 ChallengeResponseAuthentication no
 PidFile /var/run/""" + ssh_name + """.pid
 """)
 
     Linux.service_install(ssh_name,
 """[Unit]
 Description=OpenBSD Secure Shell server for Isabelle/Phabricator
 After=network.target auditd.service
 ConditionPathExists=!/etc/ssh/sshd_not_to_be_run
 
 [Service]
 EnvironmentFile=-/etc/default/ssh
 ExecStartPre=/usr/sbin/sshd -f """ + sshd_conf_server.implode + """ -t
 ExecStart=/usr/sbin/sshd -f """ + sshd_conf_server.implode + """ -D $SSHD_OPTS
 ExecReload=/usr/sbin/sshd -f """ + sshd_conf_server.implode + """ -t
 ExecReload=/bin/kill -HUP $MAINPID
 KillMode=process
 Restart=on-failure
 RestartPreventExitStatus=255
 Type=notify
 RuntimeDirectory=sshd-phabricator
 RuntimeDirectoryMode=0755
 
 [Install]
 WantedBy=multi-user.target
 Alias=""" + ssh_name + """.service
 """)
 
     for (config <- configs) {
       progress.echo("phabricator " + quote(config.name) + " port " +  server_port)
       config.execute("config set diffusion.ssh-port " + Bash.string(server_port.toString))
       if (server_port == SSH.default_port) config.execute("config delete diffusion.ssh-port")
     }
   }
 
 
   /* Isabelle tool wrapper */
 
   val isabelle_tool4 =
     Isabelle_Tool("phabricator_setup_ssh", "setup ssh service for all Phabricator installations",
       Scala_Project.here, args =>
     {
       var server_port = default_server_port
       var system_port = default_system_port
 
       val getopts =
         Getopts("""
 Usage: isabelle phabricator_setup_ssh [OPTIONS]
 
   Options are:
     -p PORT      sshd port for Phabricator servers (default: """ + default_server_port + """)
     -q PORT      sshd port for the operating system (default: """ + default_system_port + """)
 
   Configure ssh service for all Phabricator installations: a separate sshd
   is run in addition to the one of the operating system, and ports need to
   be distinct.
 
   A particular Phabricator installation is addressed by using its
   name as the ssh user; the actual Phabricator user is determined via
   stored ssh keys.
 """,
           "p:" -> (arg => server_port = Value.Int.parse(arg)),
           "q:" -> (arg => system_port = Value.Int.parse(arg)))
 
       val more_args = getopts(args)
       if (more_args.nonEmpty) getopts.usage()
 
       val progress = new Console_Progress
 
       phabricator_setup_ssh(
         server_port = server_port, system_port = system_port, progress = progress)
     })
 
 
 
   /** conduit API **/
 
   object API
   {
     /* user information */
 
     sealed case class User(
       id: Long,
       phid: String,
       name: String,
       real_name: String,
       roles: List[String])
     {
       def is_valid: Boolean =
         roles.contains("verified") &&
         roles.contains("approved") &&
         roles.contains("activated")
       def is_admin: Boolean = roles.contains("admin")
       def is_regular: Boolean = !(roles.contains("bot") || roles.contains("list"))
     }
 
 
     /* repository information */
 
     sealed case class Repository(
       vcs: VCS.Value,
       id: Long,
       phid: String,
       name: String,
       callsign: String,
       short_name: String,
       importing: Boolean,
       ssh_url: String)
     {
       def is_hg: Boolean = vcs == VCS.hg
     }
 
     object VCS extends Enumeration
     {
       val hg, git, svn = Value
       def read(s: String): Value =
         try { withName(s) }
         catch { case _: java.util.NoSuchElementException  => error("Unknown vcs type " + quote(s)) }
     }
 
     def edits(typ: String, value: JSON.T): List[JSON.Object.T] =
       List(JSON.Object("type" -> typ, "value" -> value))
 
     def opt_edits(typ: String, value: Option[JSON.T]): List[JSON.Object.T] =
       value.toList.flatMap(edits(typ, _))
 
 
     /* result with optional error */
 
     sealed case class Result(result: JSON.T, error: Option[String])
     {
       def ok: Boolean = error.isEmpty
       def get: JSON.T = if (ok) result else Exn.error(error.get)
 
       def get_value[A](unapply: JSON.T => Option[A]): A =
         unapply(get) getOrElse Exn.error("Bad JSON result: " + JSON.Format(result))
 
       def get_string: String = get_value(JSON.Value.String.unapply)
     }
 
     def make_result(json: JSON.T): Result =
     {
       val result = JSON.value(json, "result").getOrElse(JSON.Object.empty)
       val error_info = JSON.string(json, "error_info")
       val error_code = JSON.string(json, "error_code")
       Result(result, error_info orElse error_code)
     }
 
 
     /* context for operations */
 
     def apply(user: String, host: String, port: Int = SSH.default_port): API =
       new API(user, host, port)
   }
 
   final class API private(ssh_user: String, ssh_host: String, ssh_port: Int)
   {
     /* connection */
 
-    require(ssh_host.nonEmpty && ssh_port >= 0)
+    require(ssh_host.nonEmpty && ssh_port >= 0, "bad ssh host or port")
 
     private def ssh_user_prefix: String = SSH.user_prefix(ssh_user)
     private def ssh_port_suffix: String = SSH.port_suffix(ssh_port)
 
     override def toString: String = ssh_user_prefix + ssh_host + ssh_port_suffix
     def hg_url: String = "ssh://" + ssh_user_prefix + ssh_host + ssh_port_suffix
 
 
     /* execute methods */
 
     def execute_raw(method: String, params: JSON.T = JSON.Object.empty): JSON.T =
     {
       Isabelle_System.with_tmp_file("params", "json")(params_file =>
       {
         File.write(params_file, JSON.Format(JSON.Object("params" -> JSON.Format(params))))
         val result =
           Isabelle_System.bash(
             "ssh -p " + ssh_port + " " + Bash.string(ssh_user_prefix + ssh_host) +
             " conduit " + Bash.string(method) + " < " + File.bash_path(params_file)).check
         JSON.parse(result.out, strict = false)
       })
     }
 
     def execute(method: String, params: JSON.T = JSON.Object.empty): API.Result =
       API.make_result(execute_raw(method, params = params))
 
     def execute_search[A](
       method: String, params: JSON.Object.T, unapply: JSON.T => Option[A]): List[A] =
     {
       val results = new mutable.ListBuffer[A]
       var after = ""
 
       do {
         val result =
           execute(method, params = params ++ JSON.optional("after" -> proper_string(after)))
         results ++= result.get_value(JSON.list(_, "data", unapply))
         after = result.get_value(JSON.value(_, "cursor", JSON.string0(_, "after")))
       } while (after.nonEmpty)
 
       results.toList
     }
 
     def ping(): String = execute("conduit.ping").get_string
 
 
     /* users */
 
     lazy val user_phid: String = execute("user.whoami").get_value(JSON.string(_, "phid"))
     lazy val user_name: String = execute("user.whoami").get_value(JSON.string(_, "userName"))
 
     def get_users(
       all: Boolean = false,
       phid: String = "",
       name: String = ""): List[API.User] =
     {
       val constraints: JSON.Object.T =
         (for { (key, value) <- List("phids" -> phid, "usernames" -> name) if value.nonEmpty }
           yield (key, List(value))).toMap
 
       execute_search("user.search",
           JSON.Object("queryKey" -> (if (all) "all" else "active"), "constraints" -> constraints),
             data => JSON.value(data, "fields", fields =>
               for {
                 id <- JSON.long(data, "id")
                 phid <- JSON.string(data, "phid")
                 name <- JSON.string(fields, "username")
                 real_name <- JSON.string0(fields, "realName")
                 roles <- JSON.strings(fields, "roles")
               } yield API.User(id, phid, name, real_name, roles)))
     }
 
     def the_user(phid: String): API.User =
       get_users(phid = phid) match {
         case List(user) => user
         case _ => error("Bad user PHID " + quote(phid))
       }
 
 
     /* repositories */
 
     def get_repositories(
       all: Boolean = false,
       phid: String = "",
       callsign: String = "",
       short_name: String = ""): List[API.Repository] =
     {
       val constraints: JSON.Object.T =
         (for {
           (key, value) <- List("phids" -> phid, "callsigns" -> callsign, "shortNames" -> short_name)
           if value.nonEmpty
         } yield (key, List(value))).toMap
 
       execute_search("diffusion.repository.search",
           JSON.Object("queryKey" -> (if (all) "all" else "active"), "constraints" -> constraints),
             data => JSON.value(data, "fields", fields =>
               for {
                 vcs_name <- JSON.string(fields, "vcs")
                 id <- JSON.long(data, "id")
                 phid <- JSON.string(data, "phid")
                 name <- JSON.string(fields, "name")
                 callsign <- JSON.string0(fields, "callsign")
                 short_name <- JSON.string0(fields, "shortName")
                 importing <- JSON.bool(fields, "isImporting")
               }
               yield {
                 val vcs = API.VCS.read(vcs_name)
                 val url_path =
                   if (short_name.isEmpty) "/diffusion/" + id else "/source/" + short_name
                 val ssh_url =
                   vcs match {
                     case API.VCS.hg => hg_url + url_path
                     case API.VCS.git => hg_url + url_path + ".git"
                     case API.VCS.svn => ""
                   }
                 API.Repository(vcs, id, phid, name, callsign, short_name, importing, ssh_url)
               }))
     }
 
     def the_repository(phid: String): API.Repository =
       get_repositories(phid = phid) match {
         case List(repo) => repo
         case _ => error("Bad repository PHID " + quote(phid))
       }
 
     def create_repository(
       name: String,
       callsign: String = "",    // unique name, UPPERCASE
       short_name: String = "",  // unique name
       description: String = "",
       public: Boolean = false,
       vcs: API.VCS.Value = API.VCS.hg): API.Repository =
     {
-      require(name.nonEmpty)
+      require(name.nonEmpty, "bad repository name")
 
       val transactions =
         API.edits("vcs", vcs.toString) :::
         API.edits("name", name) :::
         API.opt_edits("callsign", proper_string(callsign)) :::
         API.opt_edits("shortName", proper_string(short_name)) :::
         API.opt_edits("description", proper_string(description)) :::
         (if (public) Nil
          else API.edits("view", user_phid) ::: API.edits("policy.push", user_phid)) :::
         API.edits("status", "active")
 
       val phid =
         execute("diffusion.repository.edit", params = JSON.Object("transactions" -> transactions))
           .get_value(JSON.value(_, "object", JSON.string(_, "phid")))
 
       execute("diffusion.looksoon", params = JSON.Object("repositories" -> List(phid))).get
 
       the_repository(phid)
     }
   }
 }
diff --git a/src/Pure/library.scala b/src/Pure/library.scala
--- a/src/Pure/library.scala
+++ b/src/Pure/library.scala
@@ -1,295 +1,295 @@
 /*  Title:      Pure/library.scala
     Author:     Makarius
 
 Basic library.
 */
 
 package isabelle
 
 
 import scala.annotation.tailrec
 import scala.collection.mutable
 import scala.util.matching.Regex
 
 
 object Library
 {
   /* resource management */
 
   def using[A <: AutoCloseable, B](a: A)(f: A => B): B =
   {
     try { f(a) }
     finally { if (a != null) a.close() }
   }
 
 
   /* integers */
 
   private val small_int = 10000
   private lazy val small_int_table =
   {
     val array = new Array[String](small_int)
     for (i <- 0 until small_int) array(i) = i.toString
     array
   }
 
   def is_small_int(s: String): Boolean =
   {
     val len = s.length
     1 <= len && len <= 4 &&
     s.forall(c => '0' <= c && c <= '9') &&
     (len == 1 || s(0) != '0')
   }
 
   def signed_string_of_long(i: Long): String =
     if (0 <= i && i < small_int) small_int_table(i.toInt)
     else i.toString
 
   def signed_string_of_int(i: Int): String =
     if (0 <= i && i < small_int) small_int_table(i)
     else i.toString
 
 
   /* separated chunks */
 
   def separate[A](s: A, list: List[A]): List[A] =
   {
     val result = new mutable.ListBuffer[A]
     var first = true
     for (x <- list) {
       if (first) {
         first = false
         result += x
       }
       else {
         result += s
         result += x
       }
     }
     result.toList
   }
 
   def separated_chunks(sep: Char => Boolean, source: CharSequence): Iterator[CharSequence] =
     new Iterator[CharSequence] {
       private val end = source.length
       private def next_chunk(i: Int): Option[(CharSequence, Int)] =
       {
         if (i < end) {
           var j = i; do j += 1 while (j < end && !sep(source.charAt(j)))
           Some((source.subSequence(i + 1, j), j))
         }
         else None
       }
       private var state: Option[(CharSequence, Int)] = if (end == 0) None else next_chunk(-1)
 
       def hasNext(): Boolean = state.isDefined
       def next(): CharSequence =
         state match {
           case Some((s, i)) => state = next_chunk(i); s
           case None => Iterator.empty.next()
         }
     }
 
   def space_explode(sep: Char, str: String): List[String] =
     separated_chunks(_ == sep, str).map(_.toString).toList
 
 
   /* lines */
 
   def terminate_lines(lines: TraversableOnce[String]): String = lines.mkString("", "\n", "\n")
 
   def cat_lines(lines: TraversableOnce[String]): String = lines.mkString("\n")
 
   def split_lines(str: String): List[String] = space_explode('\n', str)
 
   def prefix_lines(prfx: String, str: String): String =
     if (str == "") str else cat_lines(split_lines(str).map(prfx + _))
 
   def first_line(source: CharSequence): String =
   {
     val lines = separated_chunks(_ == '\n', source)
     if (lines.hasNext) lines.next.toString
     else ""
   }
 
   def encode_lines(s: String): String = s.replace('\n', '\u000b')
   def decode_lines(s: String): String = s.replace('\u000b', '\n')
 
 
   /* strings */
 
   def make_string(f: StringBuilder => Unit): String =
   {
     val s = new StringBuilder
     f(s)
     s.toString
   }
 
   def try_unprefix(prfx: String, s: String): Option[String] =
     if (s.startsWith(prfx)) Some(s.substring(prfx.length)) else None
 
   def try_unsuffix(sffx: String, s: String): Option[String] =
     if (s.endsWith(sffx)) Some(s.substring(0, s.length - sffx.length)) else None
 
   def perhaps_unprefix(prfx: String, s: String): String = try_unprefix(prfx, s) getOrElse s
   def perhaps_unsuffix(sffx: String, s: String): String = try_unsuffix(sffx, s) getOrElse s
 
   def trim_line(s: String): String =
     if (s.endsWith("\r\n")) s.substring(0, s.length - 2)
     else if (s.endsWith("\r") || s.endsWith("\n")) s.substring(0, s.length - 1)
     else s
 
   def trim_split_lines(s: String): List[String] =
     split_lines(trim_line(s)).map(trim_line)
 
   def isolate_substring(s: String): String = new String(s.toCharArray)
 
   def strip_ansi_color(s: String): String =
     s.replaceAll("""\u001b\[\d+m""", "")
 
 
   /* quote */
 
   def single_quote(s: String): String = "'" + s + "'"
 
   def quote(s: String): String = "\"" + s + "\""
 
   def try_unquote(s: String): Option[String] =
     if (s.startsWith("\"") && s.endsWith("\"")) Some(s.substring(1, s.length - 1))
     else None
 
   def perhaps_unquote(s: String): String = try_unquote(s) getOrElse s
 
   def commas(ss: Iterable[String]): String = ss.iterator.mkString(", ")
   def commas_quote(ss: Iterable[String]): String = ss.iterator.map(quote).mkString(", ")
 
 
   /* CharSequence */
 
   class Reverse(text: CharSequence, start: Int, end: Int) extends CharSequence
   {
-    require(0 <= start && start <= end && end <= text.length)
+    require(0 <= start && start <= end && end <= text.length, "bad reverse range")
 
     def this(text: CharSequence) = this(text, 0, text.length)
 
     def length: Int = end - start
     def charAt(i: Int): Char = text.charAt(end - i - 1)
 
     def subSequence(i: Int, j: Int): CharSequence =
       if (0 <= i && i <= j && j <= length) new Reverse(text, end - j, end - i)
       else throw new IndexOutOfBoundsException
 
     override def toString: String =
     {
       val buf = new StringBuilder(length)
       for (i <- 0 until length)
         buf.append(charAt(i))
       buf.toString
     }
   }
 
   class Line_Termination(text: CharSequence) extends CharSequence
   {
     def length: Int = text.length + 1
     def charAt(i: Int): Char = if (i == text.length) '\n' else text.charAt(i)
     def subSequence(i: Int, j: Int): CharSequence =
       if (j == text.length + 1) new Line_Termination(text.subSequence(i, j - 1))
       else text.subSequence(i, j)
     override def toString: String = text.toString + "\n"
   }
 
 
   /* regular expressions */
 
   def make_regex(s: String): Option[Regex] =
     try { Some(new Regex(s)) } catch { case ERROR(_) => None }
 
   def is_regex_meta(c: Char): Boolean = """()[]{}\^$|?*+.<>-=!""".contains(c)
 
   def escape_regex(s: String): String =
     if (s.exists(is_regex_meta)) {
       (for (c <- s.iterator)
        yield { if (is_regex_meta(c)) "\\" + c.toString else c.toString }).mkString
     }
     else s
 
 
   /* lists */
 
   def take_prefix[A](pred: A => Boolean, xs: List[A]): (List[A], List[A]) =
     (xs.takeWhile(pred), xs.dropWhile(pred))
 
   def take_suffix[A](pred: A => Boolean, xs: List[A]): (List[A], List[A]) =
   {
     val rev_xs = xs.reverse
     (rev_xs.dropWhile(pred).reverse, rev_xs.takeWhile(pred).reverse)
   }
 
   def trim[A](pred: A => Boolean, xs: List[A]): List[A] =
     take_suffix(pred, take_prefix(pred, xs)._2)._1
 
   def member[A, B](xs: List[A])(x: B): Boolean = xs.contains(x)
   def insert[A](x: A)(xs: List[A]): List[A] = if (xs.contains(x)) xs else x :: xs
   def remove[A, B](x: B)(xs: List[A]): List[A] = if (member(xs)(x)) xs.filterNot(_ == x) else xs
   def update[A](x: A)(xs: List[A]): List[A] = x :: remove(x)(xs)
 
   def merge[A](xs: List[A], ys: List[A]): List[A] =
     if (xs.eq(ys)) xs
     else if (xs.isEmpty) ys
     else ys.foldRight(xs)(Library.insert(_)(_))
 
   def distinct[A](xs: List[A], eq: (A, A) => Boolean = (x: A, y: A) => x == y): List[A] =
   {
     val result = new mutable.ListBuffer[A]
     xs.foreach(x => if (!result.exists(y => eq(x, y))) result += x)
     result.toList
   }
 
   def duplicates[A](lst: List[A], eq: (A, A) => Boolean = (x: A, y: A) => x == y): List[A] =
   {
     val result = new mutable.ListBuffer[A]
     @tailrec def dups(rest: List[A]): Unit =
       rest match {
         case Nil =>
         case x :: xs =>
           if (!result.exists(y => eq(x, y)) && xs.exists(y => eq(x, y))) result += x
           dups(xs)
       }
     dups(lst)
     result.toList
   }
 
   def replicate[A](n: Int, a: A): List[A] =
     if (n < 0) throw new IllegalArgumentException
     else if (n == 0) Nil
     else {
       val res = new mutable.ListBuffer[A]
       (1 to n).foreach(_ => res += a)
       res.toList
     }
 
 
   /* proper values */
 
   def proper_string(s: String): Option[String] =
     if (s == null || s == "") None else Some(s)
 
   def proper_list[A](list: List[A]): Option[List[A]] =
     if (list == null || list.isEmpty) None else Some(list)
 
 
   /* reflection */
 
   def is_subclass[A, B](a: Class[A], b: Class[B]): Boolean =
   {
     @tailrec def subclass(c: Class[_]): Boolean =
     {
       c == b ||
         {
           val d = c.getSuperclass
           d != null && subclass(d)
         }
     }
     subclass(a)
   }
 }
diff --git a/src/Tools/VSCode/src/lsp.scala b/src/Tools/VSCode/src/lsp.scala
--- a/src/Tools/VSCode/src/lsp.scala
+++ b/src/Tools/VSCode/src/lsp.scala
@@ -1,626 +1,626 @@
 /*  Title:      Tools/VSCode/src/lsp.scala
     Author:     Makarius
 
 Message formats for Language Server Protocol 3.0, see
 https://github.com/Microsoft/language-server-protocol/blob/master/protocol.md
 */
 
 package isabelle.vscode
 
 
 import isabelle._
 
 import java.io.{File => JFile}
 
 
 object LSP
 {
   /* abstract message */
 
   object Message
   {
     val empty: JSON.Object.T = JSON.Object("jsonrpc" -> "2.0")
 
     def log(prefix: String, json: JSON.T, logger: Logger, verbose: Boolean)
     {
       val header =
         json match {
           case JSON.Object(obj) => obj -- (obj.keySet - "method" - "id")
           case _ => JSON.Object.empty
         }
       if (verbose || header.isEmpty) logger(prefix + "\n" + JSON.Format(json))
       else logger(prefix + " " + JSON.Format(header))
     }
   }
 
 
   /* notification */
 
   object Notification
   {
     def apply(method: String, params: JSON.T): JSON.T =
       Message.empty + ("method" -> method) + ("params" -> params)
 
     def unapply(json: JSON.T): Option[(String, Option[JSON.T])] =
       for {
         method <- JSON.string(json, "method")
         params = JSON.value(json, "params")
       } yield (method, params)
   }
 
   class Notification0(name: String)
   {
     def unapply(json: JSON.T): Option[Unit] =
       json match {
         case Notification(method, _) if method == name => Some(())
         case _ => None
       }
   }
 
 
   /* request message */
 
   object Id
   {
     def empty: Id = Id("")
   }
 
   sealed case class Id(id: Any)
   {
     require(
       id.isInstanceOf[Int] ||
       id.isInstanceOf[Long] ||
       id.isInstanceOf[Double] ||
-      id.isInstanceOf[String])
+      id.isInstanceOf[String], "bad id type")
 
     override def toString: String = id.toString
   }
 
   object RequestMessage
   {
     def apply(id: Id, method: String, params: JSON.T): JSON.T =
       Message.empty + ("id" -> id.id) + ("method" -> method) + ("params" -> params)
 
     def unapply(json: JSON.T): Option[(Id, String, Option[JSON.T])] =
       for {
         id <- JSON.long(json, "id") orElse JSON.double(json, "id") orElse JSON.string(json, "id")
         method <- JSON.string(json, "method")
         params = JSON.value(json, "params")
       } yield (Id(id), method, params)
   }
 
   class Request0(name: String)
   {
     def unapply(json: JSON.T): Option[Id] =
       json match {
         case RequestMessage(id, method, _) if method == name => Some(id)
         case _ => None
       }
   }
 
   class RequestTextDocumentPosition(name: String)
   {
     def unapply(json: JSON.T): Option[(Id, Line.Node_Position)] =
       json match {
         case RequestMessage(id, method, Some(TextDocumentPosition(node_pos))) if method == name =>
           Some((id, node_pos))
         case _ => None
       }
   }
 
 
   /* response message */
 
   object ResponseMessage
   {
     def apply(id: Id, result: Option[JSON.T] = None, error: Option[ResponseError] = None): JSON.T =
       Message.empty + ("id" -> id.id) ++
         JSON.optional("result" -> result) ++
         JSON.optional("error" -> error.map(_.json))
 
     def strict(id: Id, result: Option[JSON.T] = None, error: String = ""): JSON.T =
       if (error == "") apply(id, result = result)
       else apply(id, error = Some(ResponseError(code = ErrorCodes.serverErrorEnd, message = error)))
 
     def is_empty(json: JSON.T): Boolean =
       JSON.string(json, "id") == Some("") && JSON.value(json, "result").isDefined
   }
 
   sealed case class ResponseError(code: Int, message: String, data: Option[JSON.T] = None)
   {
     def json: JSON.T =
       JSON.Object("code" -> code, "message" -> message) ++ JSON.optional("data" -> data)
   }
 
   object ErrorCodes
   {
     val ParseError = -32700
     val InvalidRequest = -32600
     val MethodNotFound = -32601
     val InvalidParams = -32602
     val InternalError = -32603
     val serverErrorStart = -32099
     val serverErrorEnd = -32000
   }
 
 
   /* init and exit */
 
   object Initialize extends Request0("initialize")
   {
     def reply(id: Id, error: String): JSON.T =
       ResponseMessage.strict(
         id, Some(JSON.Object("capabilities" -> ServerCapabilities.json)), error)
   }
 
   object ServerCapabilities
   {
     val json: JSON.T =
       JSON.Object(
         "textDocumentSync" -> 2,
         "completionProvider" -> JSON.Object("resolveProvider" -> false, "triggerCharacters" -> Nil),
         "hoverProvider" -> true,
         "definitionProvider" -> true,
         "documentHighlightProvider" -> true)
   }
 
   object Initialized extends Notification0("initialized")
 
   object Shutdown extends Request0("shutdown")
   {
     def reply(id: Id, error: String): JSON.T =
       ResponseMessage.strict(id, Some("OK"), error)
   }
 
   object Exit extends Notification0("exit")
 
 
   /* document positions */
 
   object Position
   {
     def apply(pos: Line.Position): JSON.T =
       JSON.Object("line" -> pos.line, "character" -> pos.column)
 
     def unapply(json: JSON.T): Option[Line.Position] =
       for {
         line <- JSON.int(json, "line")
         column <- JSON.int(json, "character")
       } yield Line.Position(line, column)
   }
 
   object Range
   {
     def compact(range: Line.Range): List[Int] =
       List(range.start.line, range.start.column, range.stop.line, range.stop.column)
 
     def apply(range: Line.Range): JSON.T =
       JSON.Object("start" -> Position(range.start), "end" -> Position(range.stop))
 
     def unapply(json: JSON.T): Option[Line.Range] =
       (JSON.value(json, "start"), JSON.value(json, "end")) match {
         case (Some(Position(start)), Some(Position(stop))) => Some(Line.Range(start, stop))
         case _ => None
       }
   }
 
   object Location
   {
     def apply(loc: Line.Node_Range): JSON.T =
       JSON.Object("uri" -> Url.print_file_name(loc.name), "range" -> Range(loc.range))
 
     def unapply(json: JSON.T): Option[Line.Node_Range] =
       for {
         uri <- JSON.string(json, "uri")
         range_json <- JSON.value(json, "range")
         range <- Range.unapply(range_json)
       } yield Line.Node_Range(Url.absolute_file_name(uri), range)
   }
 
   object TextDocumentPosition
   {
     def unapply(json: JSON.T): Option[Line.Node_Position] =
       for {
         doc <- JSON.value(json, "textDocument")
         uri <- JSON.string(doc, "uri")
         pos_json <- JSON.value(json, "position")
         pos <- Position.unapply(pos_json)
       } yield Line.Node_Position(Url.absolute_file_name(uri), pos)
   }
 
 
   /* marked strings */
 
   sealed case class MarkedString(text: String, language: String = "plaintext")
   {
     def json: JSON.T = JSON.Object("language" -> language, "value" -> text)
   }
 
   object MarkedStrings
   {
     def json(msgs: List[MarkedString]): Option[JSON.T] =
       msgs match {
         case Nil => None
         case List(msg) => Some(msg.json)
         case _ => Some(msgs.map(_.json))
       }
   }
 
 
   /* diagnostic messages */
 
   object MessageType
   {
     val Error = 1
     val Warning = 2
     val Info = 3
     val Log = 4
   }
 
   object DisplayMessage
   {
     def apply(message_type: Int, message: String, show: Boolean = true): JSON.T =
       Notification(if (show) "window/showMessage" else "window/logMessage",
         JSON.Object("type" -> message_type, "message" -> message))
   }
 
 
   /* commands */
 
   sealed case class Command(title: String, command: String, arguments: List[JSON.T] = Nil)
   {
     def json: JSON.T =
       JSON.Object("title" -> title, "command" -> command, "arguments" -> arguments)
   }
 
 
   /* document edits */
 
   object DidOpenTextDocument
   {
     def unapply(json: JSON.T): Option[(JFile, String, Long, String)] =
       json match {
         case Notification("textDocument/didOpen", Some(params)) =>
           for {
             doc <- JSON.value(params, "textDocument")
             uri <- JSON.string(doc, "uri")
             lang <- JSON.string(doc, "languageId")
             version <- JSON.long(doc, "version")
             text <- JSON.string(doc, "text")
           } yield (Url.absolute_file(uri), lang, version, text)
         case _ => None
       }
   }
 
 
   sealed case class TextDocumentChange(range: Option[Line.Range], text: String)
 
   object DidChangeTextDocument
   {
     def unapply_change(json: JSON.T): Option[TextDocumentChange] =
       for { text <- JSON.string(json, "text") }
       yield TextDocumentChange(JSON.value(json, "range", Range.unapply _), text)
 
     def unapply(json: JSON.T): Option[(JFile, Long, List[TextDocumentChange])] =
       json match {
         case Notification("textDocument/didChange", Some(params)) =>
           for {
             doc <- JSON.value(params, "textDocument")
             uri <- JSON.string(doc, "uri")
             version <- JSON.long(doc, "version")
             changes <- JSON.list(params, "contentChanges", unapply_change _)
           } yield (Url.absolute_file(uri), version, changes)
         case _ => None
       }
   }
 
   class TextDocumentNotification(name: String)
   {
     def unapply(json: JSON.T): Option[JFile] =
       json match {
         case Notification(method, Some(params)) if method == name =>
           for {
             doc <- JSON.value(params, "textDocument")
             uri <- JSON.string(doc, "uri")
           } yield Url.absolute_file(uri)
         case _ => None
       }
   }
 
   object DidCloseTextDocument extends TextDocumentNotification("textDocument/didClose")
   object DidSaveTextDocument extends TextDocumentNotification("textDocument/didSave")
 
 
   /* workspace edits */
 
   sealed case class TextEdit(range: Line.Range, new_text: String)
   {
     def json: JSON.T = JSON.Object("range" -> Range(range), "newText" -> new_text)
   }
 
   sealed case class TextDocumentEdit(file: JFile, version: Long, edits: List[TextEdit])
   {
     def json: JSON.T =
       JSON.Object(
         "textDocument" -> JSON.Object("uri" -> Url.print_file(file), "version" -> version),
         "edits" -> edits.map(_.json))
   }
 
   object WorkspaceEdit
   {
     def apply(edits: List[TextDocumentEdit]): JSON.T =
       RequestMessage(Id.empty, "workspace/applyEdit",
         JSON.Object("edit" -> JSON.Object("documentChanges" -> edits.map(_.json))))
   }
 
 
   /* completion */
 
   sealed case class CompletionItem(
     label: String,
     kind: Option[Int] = None,
     detail: Option[String] = None,
     documentation: Option[String] = None,
     text: Option[String] = None,
     range: Option[Line.Range] = None,
     command: Option[Command] = None)
   {
     def json: JSON.T =
       JSON.Object("label" -> label) ++
       JSON.optional("kind" -> kind) ++
       JSON.optional("detail" -> detail) ++
       JSON.optional("documentation" -> documentation) ++
       JSON.optional("insertText" -> text) ++
       JSON.optional("range" -> range.map(Range(_))) ++
       JSON.optional("textEdit" -> range.map(r => TextEdit(r, text.getOrElse(label)).json)) ++
       JSON.optional("command" -> command.map(_.json))
   }
 
   object Completion extends RequestTextDocumentPosition("textDocument/completion")
   {
     def reply(id: Id, result: List[CompletionItem]): JSON.T =
       ResponseMessage(id, Some(result.map(_.json)))
   }
 
 
   /* spell checker */
 
   object Include_Word extends Notification0("PIDE/include_word")
   {
     val command = Command("Include word", "isabelle.include-word")
   }
 
   object Include_Word_Permanently extends Notification0("PIDE/include_word_permanently")
   {
     val command = Command("Include word permanently", "isabelle.include-word-permanently")
   }
 
   object Exclude_Word extends Notification0("PIDE/exclude_word")
   {
     val command = Command("Exclude word", "isabelle.exclude-word")
   }
 
   object Exclude_Word_Permanently extends Notification0("PIDE/exclude_word_permanently")
   {
     val command = Command("Exclude word permanently", "isabelle.exclude-word-permanently")
   }
 
   object Reset_Words extends Notification0("PIDE/reset_words")
   {
     val command = Command("Reset non-permanent words", "isabelle.reset-words")
   }
 
 
   /* hover request */
 
   object Hover extends RequestTextDocumentPosition("textDocument/hover")
   {
     def reply(id: Id, result: Option[(Line.Range, List[MarkedString])]): JSON.T =
     {
       val res =
         result match {
           case Some((range, contents)) =>
             JSON.Object(
               "contents" -> MarkedStrings.json(contents).getOrElse(Nil),
               "range" -> Range(range))
           case None => JSON.Object("contents" -> Nil)
         }
       ResponseMessage(id, Some(res))
     }
   }
 
 
   /* goto definition request */
 
   object GotoDefinition extends RequestTextDocumentPosition("textDocument/definition")
   {
     def reply(id: Id, result: List[Line.Node_Range]): JSON.T =
       ResponseMessage(id, Some(result.map(Location.apply(_))))
   }
 
 
   /* document highlights request */
 
   object DocumentHighlight
   {
     def text(range: Line.Range): DocumentHighlight = DocumentHighlight(range, Some(1))
     def read(range: Line.Range): DocumentHighlight = DocumentHighlight(range, Some(2))
     def write(range: Line.Range): DocumentHighlight = DocumentHighlight(range, Some(3))
   }
 
   sealed case class DocumentHighlight(range: Line.Range, kind: Option[Int] = None)
   {
     def json: JSON.T =
       kind match {
         case None => JSON.Object("range" -> Range(range))
         case Some(k) => JSON.Object("range" -> Range(range), "kind" -> k)
       }
   }
 
   object DocumentHighlights extends RequestTextDocumentPosition("textDocument/documentHighlight")
   {
     def reply(id: Id, result: List[DocumentHighlight]): JSON.T =
       ResponseMessage(id, Some(result.map(_.json)))
   }
 
 
   /* diagnostics */
 
   sealed case class Diagnostic(range: Line.Range, message: String,
     severity: Option[Int] = None, code: Option[Int] = None, source: Option[String] = None)
   {
     def json: JSON.T =
       Message.empty + ("range" -> Range(range)) + ("message" -> message) ++
       JSON.optional("severity" -> severity) ++
       JSON.optional("code" -> code) ++
       JSON.optional("source" -> source)
   }
 
   object DiagnosticSeverity
   {
     val Error = 1
     val Warning = 2
     val Information = 3
     val Hint = 4
   }
 
   object PublishDiagnostics
   {
     def apply(file: JFile, diagnostics: List[Diagnostic]): JSON.T =
       Notification("textDocument/publishDiagnostics",
         JSON.Object("uri" -> Url.print_file(file), "diagnostics" -> diagnostics.map(_.json)))
   }
 
 
   /* decorations */
 
   sealed case class DecorationOpts(range: Line.Range, hover_message: List[MarkedString])
   {
     def json: JSON.T =
       JSON.Object("range" -> Range.compact(range)) ++
       JSON.optional("hover_message" -> MarkedStrings.json(hover_message))
   }
 
   sealed case class Decoration(typ: String, content: List[DecorationOpts])
   {
     def json(file: JFile): JSON.T =
       Notification("PIDE/decoration",
         JSON.Object("uri" -> Url.print_file(file), "type" -> typ, "content" -> content.map(_.json)))
   }
 
 
   /* caret update: bidirectional */
 
   object Caret_Update
   {
     def apply(node_pos: Line.Node_Position, focus: Boolean): JSON.T =
       Notification("PIDE/caret_update",
         JSON.Object(
           "uri" -> Url.print_file_name(node_pos.name),
           "line" -> node_pos.pos.line,
           "character" -> node_pos.pos.column,
           "focus" -> focus))
 
     def unapply(json: JSON.T): Option[Option[(JFile, Line.Position)]] =
       json match {
         case Notification("PIDE/caret_update", Some(params)) =>
           val caret =
             for {
               uri <- JSON.string(params, "uri")
               if Url.is_wellformed_file(uri)
               pos <- Position.unapply(params)
             } yield (Url.absolute_file(uri), pos)
           Some(caret)
         case _ => None
       }
   }
 
 
   /* dynamic output */
 
   object Dynamic_Output
   {
     def apply(content: String): JSON.T =
       Notification("PIDE/dynamic_output", JSON.Object("content" -> content))
   }
 
 
   /* state output */
 
   object State_Output
   {
     def apply(id: Counter.ID, content: String): JSON.T =
       Notification("PIDE/state_output", JSON.Object("id" -> id, "content" -> content))
   }
 
   class State_Id_Notification(name: String)
   {
     def unapply(json: JSON.T): Option[Counter.ID] =
       json match {
         case Notification(method, Some(params)) if method == name => JSON.long(params, "id")
         case _ => None
       }
   }
 
   object State_Init extends Notification0("PIDE/state_init")
   object State_Exit extends State_Id_Notification("PIDE/state_exit")
   object State_Locate extends State_Id_Notification("PIDE/state_locate")
   object State_Update extends State_Id_Notification("PIDE/state_update")
 
   object State_Auto_Update
   {
     def unapply(json: JSON.T): Option[(Counter.ID, Boolean)] =
       json match {
         case Notification("PIDE/state_auto_update", Some(params)) =>
           for {
             id <- JSON.long(params, "id")
             enabled <- JSON.bool(params, "enabled")
           } yield (id, enabled)
         case _ => None
       }
   }
 
 
   /* preview */
 
   object Preview_Request
   {
     def unapply(json: JSON.T): Option[(JFile, Int)] =
       json match {
         case Notification("PIDE/preview_request", Some(params)) =>
           for {
             uri <- JSON.string(params, "uri")
             if Url.is_wellformed_file(uri)
             column <- JSON.int(params, "column")
           } yield (Url.absolute_file(uri), column)
         case _ => None
       }
   }
 
   object Preview_Response
   {
     def apply(file: JFile, column: Int, label: String, content: String): JSON.T =
       Notification("PIDE/preview_response",
         JSON.Object(
           "uri" -> Url.print_file(file),
           "column" -> column,
           "label" -> label,
           "content" -> content))
   }
 
 
   /* Isabelle symbols */
 
   object Symbols_Request extends Notification0("PIDE/symbols_request")
 
   object Symbols
   {
     def apply(): JSON.T =
     {
       val entries =
         for ((sym, code) <- Symbol.codes)
         yield JSON.Object("symbol" -> sym, "name" -> Symbol.names(sym)._1, "code" -> code)
       Notification("PIDE/symbols", JSON.Object("entries" -> entries))
     }
   }
 }
diff --git a/src/Tools/jEdit/src/completion_popup.scala b/src/Tools/jEdit/src/completion_popup.scala
--- a/src/Tools/jEdit/src/completion_popup.scala
+++ b/src/Tools/jEdit/src/completion_popup.scala
@@ -1,711 +1,711 @@
 /*  Title:      Tools/jEdit/src/completion_popup.scala
     Author:     Makarius
 
 Completion popup.
 */
 
 package isabelle.jedit
 
 
 import isabelle._
 
 import java.awt.{Color, Font, Point, BorderLayout, Dimension}
 import java.awt.event.{KeyEvent, KeyListener, MouseEvent, MouseAdapter, FocusAdapter, FocusEvent}
 import java.io.{File => JFile}
 import javax.swing.{JPanel, JComponent, JLayeredPane, SwingUtilities}
 import javax.swing.border.LineBorder
 import javax.swing.text.DefaultCaret
 
 import scala.swing.{ListView, ScrollPane}
 import scala.swing.event.MouseClicked
 import org.gjt.sp.jedit.View
 import org.gjt.sp.jedit.textarea.{JEditTextArea, TextArea, Selection}
 import org.gjt.sp.jedit.gui.{HistoryTextField, KeyEventWorkaround}
 import org.gjt.sp.util.StandardUtilities
 
 
 object Completion_Popup
 {
   /** items with HTML rendering **/
 
   private class Item(val item: Completion.Item)
   {
     private val html =
       item.description match {
         case a :: bs =>
           "<html><b>" + HTML.output(Symbol.print_newlines(a)) + "</b>" +
             HTML.output(bs.map(b => " " + Symbol.print_newlines(b)).mkString) + "</html>"
         case Nil => ""
       }
     override def toString: String = html
   }
 
 
 
   /** jEdit text area **/
 
   object Text_Area
   {
     private val key = new Object
 
     def apply(text_area: TextArea): Option[Completion_Popup.Text_Area] =
     {
       GUI_Thread.require {}
       text_area.getClientProperty(key) match {
         case text_area_completion: Completion_Popup.Text_Area => Some(text_area_completion)
         case _ => None
       }
     }
 
     def active_range(text_area: TextArea): Option[Text.Range] =
       apply(text_area) match {
         case Some(text_area_completion) => text_area_completion.active_range
         case None => None
       }
 
     def action(text_area: TextArea, word_only: Boolean): Boolean =
       apply(text_area) match {
         case Some(text_area_completion) =>
           if (text_area_completion.active_range.isDefined)
             text_area_completion.action(word_only = word_only)
           else
             text_area_completion.action(immediate = true, explicit = true, word_only = word_only)
           true
         case None => false
       }
 
     def exit(text_area: JEditTextArea)
     {
       GUI_Thread.require {}
       apply(text_area) match {
         case None =>
         case Some(text_area_completion) =>
           text_area_completion.deactivate()
           text_area.putClientProperty(key, null)
       }
     }
 
     def init(text_area: JEditTextArea): Completion_Popup.Text_Area =
     {
       exit(text_area)
       val text_area_completion = new Text_Area(text_area)
       text_area.putClientProperty(key, text_area_completion)
       text_area_completion.activate()
       text_area_completion
     }
 
     def dismissed(text_area: TextArea): Boolean =
     {
       GUI_Thread.require {}
       apply(text_area) match {
         case Some(text_area_completion) => text_area_completion.dismissed()
         case None => false
       }
     }
   }
 
   class Text_Area private(text_area: JEditTextArea)
   {
     // owned by GUI thread
     private var completion_popup: Option[Completion_Popup] = None
 
     def active_range: Option[Text.Range] =
       completion_popup match {
         case Some(completion) => completion.active_range
         case None => None
       }
 
 
     /* rendering */
 
     def rendering(rendering: JEdit_Rendering, line_range: Text.Range): Option[Text.Info[Color]] =
     {
       active_range match {
         case Some(range) => range.try_restrict(line_range)
         case None =>
           val caret = text_area.getCaretPosition
           if (line_range.contains(caret)) {
             rendering.before_caret_range(caret).try_restrict(line_range) match {
               case Some(range) if !range.is_singularity =>
                 val range0 =
                   Completion.Result.merge(Completion.History.empty,
                     syntax_completion(Completion.History.empty, true, Some(rendering)),
                     rendering.path_completion(caret),
                     Document_Model.bibtex_completion(Completion.History.empty, rendering, caret))
                   .map(_.range)
                 rendering.semantic_completion(range0, range) match {
                   case None => range0
                   case Some(Text.Info(_, Completion.No_Completion)) => None
                   case Some(Text.Info(range1, _: Completion.Names)) => Some(range1)
                 }
               case _ => None
             }
           }
           else None
       }
     }.map(range => Text.Info(range, rendering.completion_color))
 
 
     /* syntax completion */
 
     def syntax_completion(
       history: Completion.History,
       explicit: Boolean,
       opt_rendering: Option[JEdit_Rendering]): Option[Completion.Result] =
     {
       val buffer = text_area.getBuffer
       val unicode = Isabelle_Encoding.is_active(buffer)
 
       Isabelle.buffer_syntax(buffer) match {
         case Some(syntax) =>
           val context =
             (for {
               rendering <- opt_rendering
               if PIDE.options.bool("jedit_completion_context")
               caret_range = rendering.before_caret_range(text_area.getCaretPosition)
               context <- rendering.language_context(caret_range)
             } yield context) getOrElse syntax.language_context
 
           val caret = text_area.getCaretPosition
           val line_range = JEdit_Lib.line_range(buffer, text_area.getCaretLine)
           val line_start = line_range.start
           for {
             line_text <- JEdit_Lib.get_text(buffer, line_range)
             result <-
               syntax.complete(
                 history, unicode, explicit, line_start, line_text, caret - line_start, context)
           } yield result
 
         case None => None
       }
     }
 
 
     /* completion action: text area */
 
     private def insert(item: Completion.Item)
     {
       GUI_Thread.require {}
 
       val buffer = text_area.getBuffer
       val range = item.range
       if (buffer.isEditable) {
         JEdit_Lib.buffer_edit(buffer) {
           JEdit_Lib.get_text(buffer, range) match {
             case Some(text) if text == item.original =>
               text_area.getSelectionAtOffset(text_area.getCaretPosition) match {
 
                 /*rectangular selection as "tall caret"*/
                 case selection : Selection.Rect
                 if selection.getStart(buffer, text_area.getCaretLine) == range.stop =>
                   text_area.moveCaretPosition(range.stop)
                   (0 until Character.codePointCount(item.original, 0, item.original.length))
                     .foreach(_ => text_area.backspace())
                   text_area.setSelectedText(selection, item.replacement)
                   text_area.moveCaretPosition(text_area.getCaretPosition + item.move)
 
                 /*other selections: rectangular, multiple range, ...*/
                 case selection
                 if selection != null &&
                     selection.getStart(buffer, text_area.getCaretLine) == range.start &&
                     selection.getEnd(buffer, text_area.getCaretLine) == range.stop =>
                   text_area.moveCaretPosition(range.stop + item.move)
                   text_area.getSelection.foreach(text_area.setSelectedText(_, item.replacement))
 
                 /*no selection*/
                 case _ =>
                   buffer.remove(range.start, range.length)
                   buffer.insert(range.start, item.replacement)
                   text_area.moveCaretPosition(range.start + item.replacement.length + item.move)
                   Isabelle.indent_input(text_area)
               }
             case _ =>
           }
         }
       }
     }
 
     def action(
       immediate: Boolean = false,
       explicit: Boolean = false,
       delayed: Boolean = false,
       word_only: Boolean = false): Boolean =
     {
       val view = text_area.getView
       val layered = view.getLayeredPane
       val buffer = text_area.getBuffer
       val painter = text_area.getPainter
 
       val history = PIDE.plugin.completion_history.value
       val unicode = Isabelle_Encoding.is_active(buffer)
 
       def open_popup(result: Completion.Result)
       {
         val font =
           painter.getFont.deriveFont(
             Font_Info.main_size(PIDE.options.real("jedit_popup_font_scale")))
 
         val range = result.range
 
         val loc1 = text_area.offsetToXY(range.start)
         if (loc1 != null) {
           val loc2 =
             SwingUtilities.convertPoint(painter,
               loc1.x, loc1.y + painter.getLineHeight, layered)
 
           val items = result.items.map(new Item(_))
           val completion =
             new Completion_Popup(Some(range), layered, loc2, font, items)
             {
               override def complete(item: Completion.Item) {
                 PIDE.plugin.completion_history.update(item)
                 insert(item)
               }
               override def propagate(evt: KeyEvent) {
                 if (view.getKeyEventInterceptor == null)
                   JEdit_Lib.propagate_key(view, evt)
                 else if (view.getKeyEventInterceptor == inner_key_listener) {
                   try {
                     view.setKeyEventInterceptor(null)
                     JEdit_Lib.propagate_key(view, evt)
                   }
                   finally {
                     if (isDisplayable) view.setKeyEventInterceptor(inner_key_listener)
                   }
                 }
                 if (evt.getID == KeyEvent.KEY_TYPED) input(evt)
               }
               override def shutdown(focus: Boolean) {
                 if (view.getKeyEventInterceptor == inner_key_listener)
                   view.setKeyEventInterceptor(null)
                 if (focus) text_area.requestFocus
                 JEdit_Lib.invalidate_range(text_area, range)
               }
             }
           dismissed()
           completion_popup = Some(completion)
           view.setKeyEventInterceptor(completion.inner_key_listener)
           JEdit_Lib.invalidate_range(text_area, range)
           Pretty_Tooltip.dismissed_all()
           completion.show_popup(false)
         }
       }
 
       if (buffer.isEditable) {
         val caret = text_area.getCaretPosition
         val opt_rendering = Document_View.get(text_area).map(_.get_rendering())
         val result0 = syntax_completion(history, explicit, opt_rendering)
         val (no_completion, semantic_completion) =
         {
           opt_rendering match {
             case Some(rendering) =>
               rendering.semantic_completion_result(history, unicode, result0.map(_.range),
                 rendering.before_caret_range(caret))
             case None => (false, None)
           }
         }
         if (no_completion) false
         else {
           val result =
           {
             val result1 =
               if (word_only) None
               else Completion.Result.merge(history, semantic_completion, result0)
             opt_rendering match {
               case None => result1
               case Some(rendering) =>
                 Completion.Result.merge(history,
                   result1,
                   JEdit_Spell_Checker.completion(rendering, explicit, caret),
                   rendering.path_completion(caret),
                   Document_Model.bibtex_completion(history, rendering, caret))
             }
           }
           result match {
             case Some(result) =>
               result.items match {
                 case List(item) if result.unique && item.immediate && immediate =>
                   insert(item)
                   true
                 case _ :: _ if !delayed =>
                   open_popup(result)
                   false
                 case _ => false
               }
             case None => false
           }
         }
       }
       else false
     }
 
 
     /* input key events */
 
     def input(evt: KeyEvent)
     {
       GUI_Thread.require {}
 
       if (!evt.isConsumed) {
         val special = JEdit_Lib.special_key(evt)
 
         if (PIDE.options.bool("jedit_completion")) {
           dismissed()
           if (evt.getKeyChar != '\b') {
             val immediate = PIDE.options.bool("jedit_completion_immediate")
             if (PIDE.options.seconds("jedit_completion_delay").is_zero && !special) {
               input_delay.revoke()
               action(immediate = immediate)
             }
             else {
               if (!special && action(immediate = immediate, delayed = true))
                 input_delay.revoke()
               else
                 input_delay.invoke()
             }
           }
         }
 
         val selection = text_area.getSelection()
         if (!special && (selection == null || selection.isEmpty))
           Isabelle.indent_input(text_area)
       }
     }
 
     private val input_delay =
       Delay.last(PIDE.options.seconds("jedit_completion_delay"), gui = true) {
         action()
       }
 
 
     /* dismiss popup */
 
     def dismissed(): Boolean =
     {
       GUI_Thread.require {}
 
       completion_popup match {
         case Some(completion) =>
           completion.hide_popup()
           completion_popup = None
           true
         case None =>
           false
       }
     }
 
 
     /* activation */
 
     private val outer_key_listener =
       JEdit_Lib.key_listener(key_typed = input)
 
     private def activate()
     {
       text_area.addKeyListener(outer_key_listener)
     }
 
     private def deactivate()
     {
       dismissed()
       text_area.removeKeyListener(outer_key_listener)
     }
   }
 
 
 
   /** history text field **/
 
   class History_Text_Field(
     name: String = null,
     instant_popups: Boolean = false,
     enter_adds_to_history: Boolean = true,
     syntax: Outer_Syntax = Outer_Syntax.empty) extends
     HistoryTextField(name, instant_popups, enter_adds_to_history)
   {
     text_field =>
 
     // see https://forums.oracle.com/thread/1361677
     if (GUI.is_macos_laf) text_field.setCaret(new DefaultCaret)
 
     // owned by GUI thread
     private var completion_popup: Option[Completion_Popup] = None
 
 
     /* dismiss */
 
     private def dismissed(): Boolean =
     {
       completion_popup match {
         case Some(completion) =>
           completion.hide_popup()
           completion_popup = None
           true
         case None =>
           false
       }
     }
 
 
     /* insert */
 
     private def insert(item: Completion.Item)
     {
       GUI_Thread.require {}
 
       val range = item.range
       if (text_field.isEditable) {
         val content = text_field.getText
         range.try_substring(content) match {
           case Some(text) if text == item.original =>
             text_field.setText(
               content.substring(0, range.start) +
               item.replacement +
               content.substring(range.stop))
             text_field.getCaret.setDot(range.start + item.replacement.length + item.move)
           case _ =>
         }
       }
     }
 
 
     /* completion action: text field */
 
     def action()
     {
       GUI.layered_pane(text_field) match {
         case Some(layered) if text_field.isEditable =>
           val history = PIDE.plugin.completion_history.value
 
           val caret = text_field.getCaret.getDot
           val text = text_field.getText
 
           val context = syntax.language_context
 
           syntax.complete(history, true, false, 0, text, caret, context) match {
             case Some(result) =>
               val fm = text_field.getFontMetrics(text_field.getFont)
               val loc =
                 SwingUtilities.convertPoint(text_field, fm.stringWidth(text), fm.getHeight, layered)
 
               val items = result.items.map(new Item(_))
               val completion =
                 new Completion_Popup(None, layered, loc, text_field.getFont, items)
                 {
                   override def complete(item: Completion.Item) {
                     PIDE.plugin.completion_history.update(item)
                     insert(item)
                   }
                   override def propagate(evt: KeyEvent) {
                     if (!evt.isConsumed) text_field.processKeyEvent(evt)
                   }
                   override def shutdown(focus: Boolean) { if (focus) text_field.requestFocus }
                 }
               dismissed()
               completion_popup = Some(completion)
               completion.show_popup(true)
 
             case None =>
           }
         case _ =>
       }
     }
 
 
     /* process key event */
 
     private def process(evt: KeyEvent)
     {
       if (PIDE.options.bool("jedit_completion")) {
         dismissed()
         if (evt.getKeyChar != '\b') {
           val special = JEdit_Lib.special_key(evt)
           if (PIDE.options.seconds("jedit_completion_delay").is_zero && !special) {
             process_delay.revoke()
             action()
           }
           else process_delay.invoke()
         }
       }
     }
 
     private val process_delay =
       Delay.last(PIDE.options.seconds("jedit_completion_delay"), gui = true) {
         action()
       }
 
     override def processKeyEvent(evt0: KeyEvent)
     {
       val evt = KeyEventWorkaround.processKeyEvent(evt0)
       if (evt != null) {
         evt.getID match {
           case KeyEvent.KEY_PRESSED =>
             val key_code = evt.getKeyCode
             if (key_code == KeyEvent.VK_ESCAPE) {
               if (dismissed()) evt.consume
             }
           case KeyEvent.KEY_TYPED =>
             super.processKeyEvent(evt)
             process(evt)
             evt.consume
           case _ =>
         }
         if (!evt.isConsumed) super.processKeyEvent(evt)
       }
     }
   }
 }
 
 
 class Completion_Popup private(
   opt_range: Option[Text.Range],
   layered: JLayeredPane,
   location: Point,
   font: Font,
   items: List[Completion_Popup.Item]) extends JPanel(new BorderLayout)
 {
   completion =>
 
   GUI_Thread.require {}
 
-  require(items.nonEmpty)
+  require(items.nonEmpty, "no completion items")
   val multi: Boolean = items.length > 1
 
 
   /* actions */
 
   def complete(item: Completion.Item) { }
   def propagate(evt: KeyEvent) { }
   def shutdown(focus: Boolean) { }
 
 
   /* list view */
 
   private val list_view = new ListView(items)
   list_view.font = font
   list_view.selection.intervalMode = ListView.IntervalMode.Single
   list_view.peer.setFocusTraversalKeysEnabled(false)
   list_view.peer.setVisibleRowCount(items.length min 8)
   list_view.peer.setSelectedIndex(0)
 
   for (cond <-
     List(JComponent.WHEN_FOCUSED,
       JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT,
       JComponent.WHEN_IN_FOCUSED_WINDOW)) list_view.peer.setInputMap(cond, null)
 
   private def complete_selected(): Boolean =
   {
     list_view.selection.items.toList match {
       case item :: _ => complete(item.item); true
       case _ => false
     }
   }
 
   private def move_items(n: Int)
   {
     val i = list_view.peer.getSelectedIndex
     val j = ((i + n) min (items.length - 1)) max 0
     if (i != j) {
       list_view.peer.setSelectedIndex(j)
       list_view.peer.ensureIndexIsVisible(j)
     }
   }
 
   private def move_pages(n: Int)
   {
     val page_size = list_view.peer.getVisibleRowCount - 1
     move_items(page_size * n)
   }
 
 
   /* event handling */
 
   val inner_key_listener: KeyListener =
     JEdit_Lib.key_listener(
       key_pressed = (e: KeyEvent) =>
         {
           if (!e.isConsumed) {
             e.getKeyCode match {
               case KeyEvent.VK_ENTER if PIDE.options.bool("jedit_completion_select_enter") =>
                 if (complete_selected()) e.consume
                 hide_popup()
               case KeyEvent.VK_TAB if PIDE.options.bool("jedit_completion_select_tab") =>
                 if (complete_selected()) e.consume
                 hide_popup()
               case KeyEvent.VK_ESCAPE =>
                 hide_popup()
                 e.consume
               case KeyEvent.VK_UP | KeyEvent.VK_KP_UP if multi =>
                 move_items(-1)
                 e.consume
               case KeyEvent.VK_DOWN | KeyEvent.VK_KP_DOWN if multi =>
                 move_items(1)
                 e.consume
               case KeyEvent.VK_PAGE_UP if multi =>
                 move_pages(-1)
                 e.consume
               case KeyEvent.VK_PAGE_DOWN if multi =>
                 move_pages(1)
                 e.consume
               case _ =>
                 if (e.isActionKey || e.isAltDown || e.isMetaDown || e.isControlDown)
                   hide_popup()
             }
           }
           propagate(e)
         },
       key_typed = propagate
     )
 
   list_view.peer.addKeyListener(inner_key_listener)
 
   list_view.peer.addMouseListener(new MouseAdapter {
     override def mouseClicked(e: MouseEvent) {
       if (complete_selected()) e.consume
       hide_popup()
     }
   })
 
   list_view.peer.addFocusListener(new FocusAdapter {
     override def focusLost(e: FocusEvent) { hide_popup() }
   })
 
 
   /* main content */
 
   override def getFocusTraversalKeysEnabled = false
   completion.setBorder(new LineBorder(Color.BLACK))
   completion.add((new ScrollPane(list_view)).peer.asInstanceOf[JComponent])
 
 
   /* popup */
 
   def active_range: Option[Text.Range] =
     if (isDisplayable) opt_range else None
 
   private val popup =
   {
     val screen = GUI.screen_location(layered, location)
     val size =
     {
       val geometry = JEdit_Lib.window_geometry(completion, completion)
       val bounds = JEdit_Rendering.popup_bounds
       val w = geometry.width min (screen.bounds.width * bounds).toInt min layered.getWidth
       val h = geometry.height min (screen.bounds.height * bounds).toInt min layered.getHeight
       new Dimension(w, h)
     }
     new Popup(layered, completion, screen.relative(layered, size), size)
   }
 
   private def show_popup(focus: Boolean)
   {
     popup.show
     if (focus) list_view.requestFocus
   }
 
   private def hide_popup()
   {
     shutdown(list_view.peer.isFocusOwner)
     popup.hide
   }
 }
diff --git a/src/Tools/jEdit/src/pretty_text_area.scala b/src/Tools/jEdit/src/pretty_text_area.scala
--- a/src/Tools/jEdit/src/pretty_text_area.scala
+++ b/src/Tools/jEdit/src/pretty_text_area.scala
@@ -1,245 +1,245 @@
 /*  Title:      Tools/jEdit/src/pretty_text_area.scala
     Author:     Makarius
 
 GUI component for pretty-printed text with markup, rendered like jEdit
 text area.
 */
 
 package isabelle.jedit
 
 
 import isabelle._
 
 import java.awt.{Color, Font, Toolkit, Window}
 import java.awt.event.{InputEvent, KeyEvent}
 import java.awt.im.InputMethodRequests
 import javax.swing.JTextField
 import javax.swing.event.{DocumentListener, DocumentEvent}
 
 import scala.swing.{Label, Component}
 import scala.util.matching.Regex
 
 import org.gjt.sp.jedit.{jEdit, View, Registers, JEditBeanShellAction}
 import org.gjt.sp.jedit.input.{DefaultInputHandlerProvider, TextAreaInputHandler}
 import org.gjt.sp.jedit.textarea.{AntiAlias, JEditEmbeddedTextArea}
 import org.gjt.sp.jedit.syntax.SyntaxStyle
 import org.gjt.sp.jedit.gui.KeyEventTranslator
 import org.gjt.sp.util.{SyntaxUtilities, Log}
 
 
 class Pretty_Text_Area(
   view: View,
   close_action: () => Unit = () => (),
   propagate_keys: Boolean = false) extends JEditEmbeddedTextArea
 {
   text_area =>
 
   GUI_Thread.require {}
 
   private var current_font_info: Font_Info = Font_Info.main()
   private var current_body: XML.Body = Nil
   private var current_base_snapshot = Document.Snapshot.init
   private var current_base_results = Command.Results.empty
   private var current_rendering: JEdit_Rendering =
     JEdit_Rendering.text(current_base_snapshot, Nil)._2
   private var future_refresh: Option[Future[Unit]] = None
 
   private val rich_text_area =
     new Rich_Text_Area(view, text_area, () => current_rendering, close_action,
       get_search_pattern _, () => (), caret_visible = false, enable_hovering = true)
 
   private var current_search_pattern: Option[Regex] = None
   def get_search_pattern(): Option[Regex] = GUI_Thread.require { current_search_pattern }
 
   def get_background(): Option[Color] = None
 
   def refresh()
   {
     GUI_Thread.require {}
 
     val font = current_font_info.font
     getPainter.setFont(font)
     getPainter.setAntiAlias(new AntiAlias(jEdit.getProperty("view.antiAlias")))
     getPainter.setFractionalFontMetricsEnabled(jEdit.getBooleanProperty("view.fracFontMetrics"))
     getPainter.setStyles(
       SyntaxUtilities.loadStyles(current_font_info.family, current_font_info.size.round))
     getPainter.setLineExtraSpacing(jEdit.getIntegerProperty("options.textarea.lineSpacing", 0))
 
     val fold_line_style = new Array[SyntaxStyle](4)
     for (i <- 0 to 3) {
       fold_line_style(i) =
         SyntaxUtilities.parseStyle(
           jEdit.getProperty("view.style.foldLine." + i),
           current_font_info.family, current_font_info.size.round, true)
     }
     getPainter.setFoldLineStyle(fold_line_style)
 
     getGutter.setForeground(jEdit.getColorProperty("view.gutter.fgColor"))
     getGutter.setBackground(jEdit.getColorProperty("view.gutter.bgColor"))
     get_background().foreach(bg => { getPainter.setBackground(bg); getGutter.setBackground(bg) })
     getGutter.setHighlightedForeground(jEdit.getColorProperty("view.gutter.highlightColor"))
     getGutter.setFoldColor(jEdit.getColorProperty("view.gutter.foldColor"))
     getGutter.setFont(jEdit.getFontProperty("view.gutter.font"))
     getGutter.setBorder(0,
       jEdit.getColorProperty("view.gutter.focusBorderColor"),
       jEdit.getColorProperty("view.gutter.noFocusBorderColor"),
       getPainter.getBackground)
     getGutter.setFoldPainter(view.getTextArea.getFoldPainter)
     getGutter.setGutterEnabled(jEdit.getBooleanProperty("view.gutter.enabled"))
 
     if (getWidth > 0) {
       val metric = JEdit_Lib.pretty_metric(getPainter)
       val margin = (getPainter.getWidth.toDouble / metric.unit) max 20.0
 
       val snapshot = current_base_snapshot
       val results = current_base_results
       val formatted_body = Pretty.formatted(current_body, margin = margin, metric = metric)
 
       future_refresh.foreach(_.cancel)
       future_refresh =
         Some(Future.fork {
           val (text, rendering) =
             try { JEdit_Rendering.text(snapshot, formatted_body, results = results) }
             catch { case exn: Throwable => Log.log(Log.ERROR, this, exn); throw exn }
           Exn.Interrupt.expose()
 
           GUI_Thread.later {
             current_rendering = rendering
             JEdit_Lib.buffer_edit(getBuffer) {
               rich_text_area.active_reset()
               getBuffer.setFoldHandler(new Fold_Handling.Document_Fold_Handler(rendering))
               JEdit_Lib.buffer_undo_in_progress(getBuffer, setText(text))
               setCaretPosition(0)
             }
           }
         })
     }
   }
 
   def resize(font_info: Font_Info)
   {
     GUI_Thread.require {}
 
     current_font_info = font_info
     refresh()
   }
 
   def update(base_snapshot: Document.Snapshot, base_results: Command.Results, body: XML.Body)
   {
     GUI_Thread.require {}
-    require(!base_snapshot.is_outdated)
+    require(!base_snapshot.is_outdated, "document snapshot outdated")
 
     current_base_snapshot = base_snapshot
     current_base_results = base_results
     current_body = body
     refresh()
   }
 
   def detach
   {
     GUI_Thread.require {}
     Info_Dockable(view, current_base_snapshot, current_base_results, current_body)
   }
 
   def detach_operation: Option[() => Unit] =
     if (current_body.isEmpty) None else Some(() => detach)
 
 
   /* common GUI components */
 
   val search_label: Component = new Label("Search:") {
     tooltip = "Search and highlight output via regular expression"
   }
 
   val search_field: Component =
     Component.wrap(new Completion_Popup.History_Text_Field("isabelle-search")
       {
         private val input_delay =
           Delay.last(PIDE.options.seconds("editor_input_delay"), gui = true) {
             search_action(this)
           }
         getDocument.addDocumentListener(new DocumentListener {
           def changedUpdate(e: DocumentEvent) { input_delay.invoke() }
           def insertUpdate(e: DocumentEvent) { input_delay.invoke() }
           def removeUpdate(e: DocumentEvent) { input_delay.invoke() }
         })
         setColumns(20)
         setToolTipText(search_label.tooltip)
         setFont(GUI.imitate_font(getFont, scale = 1.2))
       })
 
   private val search_field_foreground = search_field.foreground
 
   private def search_action(text_field: JTextField)
   {
     val (pattern, ok) =
       text_field.getText match {
         case null | "" => (None, true)
         case s =>
           val re = Library.make_regex(s)
           (re, re.isDefined)
       }
     if (current_search_pattern != pattern) {
       current_search_pattern = pattern
       text_area.getPainter.repaint()
     }
     text_field.setForeground(
       if (ok) search_field_foreground
       else current_rendering.color(Rendering.Color.error))
   }
 
 
   /* key handling */
 
   override def getInputMethodRequests: InputMethodRequests = null
 
   inputHandlerProvider =
     new DefaultInputHandlerProvider(new TextAreaInputHandler(text_area) {
       override def getAction(action: String): JEditBeanShellAction =
         text_area.getActionContext.getAction(action)
       override def processKeyEvent(evt: KeyEvent, from: Int, global: Boolean) {}
       override def handleKey(key: KeyEventTranslator.Key, dry_run: Boolean): Boolean = false
     })
 
   addKeyListener(JEdit_Lib.key_listener(
     key_pressed = (evt: KeyEvent) =>
       {
         val strict_control =
           JEdit_Lib.command_modifier(evt) && !JEdit_Lib.shift_modifier(evt)
 
         evt.getKeyCode match {
           case KeyEvent.VK_C | KeyEvent.VK_INSERT
           if strict_control && text_area.getSelectionCount != 0 =>
             Registers.copy(text_area, '$')
             evt.consume
 
           case KeyEvent.VK_A
           if strict_control =>
             text_area.selectAll
             evt.consume
 
           case KeyEvent.VK_ESCAPE =>
             if (Isabelle.dismissed_popups(view)) evt.consume
 
           case _ =>
         }
         if (propagate_keys) JEdit_Lib.propagate_key(view, evt)
       },
     key_typed = (evt: KeyEvent) =>
       {
         if (propagate_keys) JEdit_Lib.propagate_key(view, evt)
       }
     )
   )
 
 
   /* init */
 
   getPainter.setStructureHighlightEnabled(false)
   getPainter.setLineHighlightEnabled(false)
 
   getBuffer.setTokenMarker(Isabelle.mode_token_marker("isabelle-output").get)
   getBuffer.setStringProperty("noWordSep", "_'?⇩")
 
   rich_text_area.activate()
 }
diff --git a/src/Tools/jEdit/src/syntax_style.scala b/src/Tools/jEdit/src/syntax_style.scala
--- a/src/Tools/jEdit/src/syntax_style.scala
+++ b/src/Tools/jEdit/src/syntax_style.scala
@@ -1,188 +1,188 @@
 /*  Title:      Tools/jEdit/src/syntax_style.scala
     Author:     Makarius
 
 Support for extended syntax styles: subscript, superscript, bold, user fonts.
 */
 
 package isabelle.jedit
 
 
 import isabelle._
 
 import java.awt.{Font, Color}
 import java.awt.font.TextAttribute
 import java.awt.geom.AffineTransform
 
 import org.gjt.sp.util.SyntaxUtilities
 import org.gjt.sp.jedit.syntax.{Token => JEditToken, SyntaxStyle}
 import org.gjt.sp.jedit.textarea.TextArea
 
 
 object Syntax_Style
 {
   /* extended syntax styles */
 
   private val plain_range: Int = JEditToken.ID_COUNT
-  private def check_range(i: Int) { require(0 <= i && i < plain_range) }
+  private def check_range(i: Int) { require(0 <= i && i < plain_range, "bad syntax style range") }
 
   def subscript(i: Byte): Byte = { check_range(i); (i + plain_range).toByte }
   def superscript(i: Byte): Byte = { check_range(i); (i + 2 * plain_range).toByte }
   def bold(i: Byte): Byte = { check_range(i); (i + 3 * plain_range).toByte }
   def user_font(idx: Int, i: Byte): Byte = { check_range(i); (i + (4 + idx) * plain_range).toByte }
   val hidden: Byte = (6 * plain_range).toByte
   val control: Byte = (hidden + JEditToken.DIGIT).toByte
 
   private def font_style(style: SyntaxStyle, f: Font => Font): SyntaxStyle =
     new SyntaxStyle(style.getForegroundColor, style.getBackgroundColor, f(style.getFont))
 
   private def script_style(style: SyntaxStyle, i: Int): SyntaxStyle =
   {
     font_style(style, font0 =>
       {
         val font1 =
           font0.deriveFont(java.util.Map.of(TextAttribute.SUPERSCRIPT, java.lang.Integer.valueOf(i)))
 
         def shift(y: Float): Font =
           GUI.transform_font(font1, AffineTransform.getTranslateInstance(0.0, y.toDouble))
 
         val m0 = GUI.line_metrics(font0)
         val m1 = GUI.line_metrics(font1)
         val a = m1.getAscent - m0.getAscent
         val b = (m1.getDescent + m1.getLeading) - (m0.getDescent + m0.getLeading)
         if (a > 0.0f) shift(a)
         else if (b > 0.0f) shift(- b)
         else font1
       })
   }
 
   private def bold_style(style: SyntaxStyle): SyntaxStyle =
     font_style(style, font => font.deriveFont(if (font.isBold) Font.PLAIN else Font.BOLD))
 
   val hidden_color: Color = new Color(255, 255, 255, 0)
 
   object Extender extends SyntaxUtilities.StyleExtender
   {
     val max_user_fonts = 2
     if (Symbol.font_names.length > max_user_fonts)
       error("Too many user symbol fonts (" + max_user_fonts + " permitted): " +
         Symbol.font_names.mkString(", "))
 
     override def extendStyles(styles: Array[SyntaxStyle]): Array[SyntaxStyle] =
     {
       val style0 = styles(0)
       val font0 = style0.getFont
 
       val new_styles = Array.fill[SyntaxStyle](java.lang.Byte.MAX_VALUE)(styles(0))
       for (i <- 0 until plain_range) {
         val style = styles(i)
         new_styles(i) = style
         new_styles(subscript(i.toByte)) = script_style(style, -1)
         new_styles(superscript(i.toByte)) = script_style(style, 1)
         new_styles(bold(i.toByte)) = bold_style(style)
         for (idx <- 0 until max_user_fonts)
           new_styles(user_font(idx, i.toByte)) = style
         for ((family, idx) <- Symbol.font_index)
           new_styles(user_font(idx, i.toByte)) = font_style(style, GUI.imitate_font(_, family))
       }
       new_styles(hidden) =
         new SyntaxStyle(hidden_color, null,
           GUI.transform_font(new Font(font0.getFamily, 0, 1),
             AffineTransform.getScaleInstance(2.0, font0.getSize.toDouble)))
       new_styles(control) =
         new SyntaxStyle(style0.getForegroundColor, style0.getBackgroundColor,
           { val font_style =
               (if (font0.isItalic) 0 else Font.ITALIC) |
               (if (font0.isBold) 0 else Font.BOLD)
             new Font(font0.getFamily, font_style, font0.getSize) })
       new_styles
     }
   }
 
   private def control_style(sym: String): Option[Byte => Byte] =
     if (sym == Symbol.sub_decoded) Some(subscript)
     else if (sym == Symbol.sup_decoded) Some(superscript)
     else if (sym == Symbol.bold_decoded) Some(bold)
     else None
 
   def extended(text: CharSequence): Map[Text.Offset, Byte => Byte] =
   {
     var result = Map[Text.Offset, Byte => Byte]()
     def mark(start: Text.Offset, stop: Text.Offset, style: Byte => Byte)
     {
       for (i <- start until stop) result += (i -> style)
     }
 
     var offset = 0
     var control_sym = ""
     for (sym <- Symbol.iterator(text)) {
       val end_offset = offset + sym.length
 
       if (control_style(sym).isDefined) control_sym = sym
       else if (control_sym != "") {
         if (Symbol.is_controllable(sym) && !Symbol.fonts.isDefinedAt(sym)) {
           mark(offset - control_sym.length, offset, _ => hidden)
           mark(offset, end_offset, control_style(control_sym).get)
         }
         control_sym = ""
       }
 
       if (Symbol.is_control_encoded(sym)) {
         val a = offset + Symbol.control_prefix.length
         val b = end_offset - Symbol.control_suffix.length
         mark(offset, a, _ => hidden)
         mark(a, b, _ => control)
         mark(b, end_offset, _ => hidden)
       }
 
       Symbol.lookup_font(sym) match {
         case Some(idx) => mark(offset, end_offset, user_font(idx, _))
         case _ =>
       }
 
       offset = end_offset
     }
 
     result
   }
 
 
   /* editing support for control symbols */
 
   def edit_control_style(text_area: TextArea, control_sym: String)
   {
     GUI_Thread.assert {}
 
     val buffer = text_area.getBuffer
 
     val control_decoded = Isabelle_Encoding.perhaps_decode(buffer, control_sym)
 
     def update_style(text: String): String =
     {
       val result = new StringBuilder
       for (sym <- Symbol.iterator(text) if !HTML.is_control(sym)) {
         if (Symbol.is_controllable(sym)) result ++= control_decoded
         result ++= sym
       }
       result.toString
     }
 
     text_area.getSelection.foreach(sel => {
       val before = JEdit_Lib.point_range(buffer, sel.getStart - 1)
       JEdit_Lib.get_text(buffer, before) match {
         case Some(s) if HTML.is_control(s) =>
           text_area.extendSelection(before.start, before.stop)
         case _ =>
       }
     })
 
     text_area.getSelection.toList match {
       case Nil =>
         text_area.setSelectedText(control_decoded)
       case sels =>
         JEdit_Lib.buffer_edit(buffer) {
           sels.foreach(sel =>
             text_area.setSelectedText(sel, update_style(text_area.getSelectedText(sel))))
         }
     }
   }
 }