src/Pure/PIDE/command_span.scala

 
 import scala.collection.mutable
 import scala.util.parsing.input.CharSequenceReader
 
 
-object Command_Span
-{
+object Command_Span {
   /* loaded files */
 
-  object Loaded_Files
-  {
+  object Loaded_Files {
     val none: Loaded_Files = Loaded_Files(Nil, -1)
   }
   sealed case class Loaded_Files(files: List[String], index: Int)
 
   abstract class Load_Command(val name: String, val here: Scala_Project.Here)
-    extends Isabelle_System.Service
-  {
+  extends Isabelle_System.Service {
     override def toString: String = name
 
     def position: Position.T = here.position
 
     def extensions: List[String] = Nil

   case object Theory_Span extends Kind
 
 
   /* span */
 
-  sealed case class Span(kind: Kind, content: List[Token])
-  {
+  sealed case class Span(kind: Kind, content: List[Token]) {
     def is_theory: Boolean = kind == Theory_Span
 
     def name: String =
       kind match { case k: Command_Span => k.name case _ => "" }
 

 
     def content_reader: CharSequenceReader = Scan.char_reader(Token.implode(content))
 
     def length: Int = content.foldLeft(0)(_ + _.source.length)
 
-    def compact_source: (String, Span) =
-    {
+    def compact_source: (String, Span) = {
       val source = Token.implode(content)
       val content1 = new mutable.ListBuffer[Token]
       var i = 0
       for (Token(kind, s) <- content) {
         val n = s.length

         i += n
       }
       (source, Span(kind, content1.toList))
     }
 
-    def clean_arguments: List[(Token, Int)] =
-    {
+    def clean_arguments: List[(Token, Int)] = {
       if (name.nonEmpty) {
         def clean(toks: List[(Token, Int)]): List[(Token, Int)] =
           toks match {
             case (t1, i1) :: (t2, i2) :: rest =>
               if (t1.is_keyword && t1.source == "%" && t2.is_name) clean(rest)

       }
   }
 
   val empty: Span = Span(Ignored_Span, Nil)
 
-  def unparsed(source: String, theory: Boolean): Span =
-  {
+  def unparsed(source: String, theory: Boolean): Span = {
     val kind = if (theory) Theory_Span else Malformed_Span
     Span(kind, List(Token(Token.Kind.UNPARSED, source)))
   }
 }