src/Pure/ML/ml_lex.scala

 
 import scala.collection.mutable
 import scala.util.parsing.input.Reader
 
 
-object ML_Lex
-{
+object ML_Lex {
   /** keywords **/
 
   val keywords: Set[String] =
     Set("#", "(", ")", ",", "->", "...", ":", ":>", ";", "=", "=>",
       "[", "]", "_", "{", "|", "}", "abstype", "and", "andalso", "as",

 
 
 
   /** tokens **/
 
-  object Kind extends Enumeration
-  {
+  object Kind extends Enumeration {
     val KEYWORD = Value("keyword")
     val IDENT = Value("identifier")
     val LONG_IDENT = Value("long identifier")
     val TYPE_VAR = Value("type variable")
     val WORD = Value("word")

     val ANTIQ_ALT_STRING = Value("antiquotation: back-quoted string")
     val ANTIQ_CARTOUCHE = Value("antiquotation: text cartouche")
     val ERROR = Value("bad input")
   }
 
-  sealed case class Token(kind: Kind.Value, source: String)
-  {
+  sealed case class Token(kind: Kind.Value, source: String) {
     def is_keyword: Boolean = kind == Kind.KEYWORD
     def is_delimiter: Boolean = is_keyword && !Symbol.is_ascii_identifier(source)
     def is_space: Boolean = kind == Kind.SPACE
     def is_comment: Boolean = kind == Kind.INFORMAL_COMMENT || kind == Kind.FORMAL_COMMENT
   }

   /** parsers **/
 
   case object ML_String extends Scan.Line_Context
   case class Antiq(ctxt: Scan.Line_Context) extends Scan.Line_Context
 
-  private object Parsers extends Scan.Parsers with Antiquote.Parsers with Comment.Parsers
-  {
+  private object Parsers extends Scan.Parsers with Antiquote.Parsers with Comment.Parsers {
     /* string material */
 
     private val blanks = many(character(Symbol.is_ascii_blank))
     private val blanks1 = many1(character(Symbol.is_ascii_blank))
 

       "\"" ~ ml_string_body ^^ { case x ~ y => x + y }
 
     private val ml_string: Parser[Token] =
       "\"" ~ ml_string_body ~ "\"" ^^ { case x ~ y ~ z => Token(Kind.STRING, x + y + z) }
 
-    private def ml_string_line(ctxt: Scan.Line_Context): Parser[(Token, Scan.Line_Context)] =
-    {
+    private def ml_string_line(ctxt: Scan.Line_Context): Parser[(Token, Scan.Line_Context)] = {
       def result(x: String, c: Scan.Line_Context) = (Token(Kind.STRING, x), c)
 
       ctxt match {
         case Scan.Finished =>
           "\"" ~ ml_string_body ~ ("\"" | gap_start) ^^

       }
 
 
     /* token */
 
-    private def other_token: Parser[Token] =
-    {
+    private def other_token: Parser[Token] = {
       /* identifiers */
 
       val letdigs = many(character(Symbol.is_ascii_letdig))
 
       val alphanumeric =

     }
 
     def token: Parser[Token] =
       ml_char | (ml_string | (ml_comment | (ml_formal_comment | other_token)))
 
-    def token_line(SML: Boolean, ctxt: Scan.Line_Context): Parser[(Token, Scan.Line_Context)] =
-    {
+    def token_line(SML: Boolean, ctxt: Scan.Line_Context): Parser[(Token, Scan.Line_Context)] = {
       val other = (ml_char | other_token) ^^ (x => (x, Scan.Finished))
 
       if (SML) ml_string_line(ctxt) | (ml_comment_line(ctxt) | other)
       else {
         ml_string_line(ctxt) |

     Parsers.parseAll(Parsers.rep(Parsers.token), Scan.char_reader(input)) match {
       case Parsers.Success(tokens, _) => tokens
       case _ => error("Unexpected failure of tokenizing input:\n" + input.toString)
     }
 
-  def tokenize_line(SML: Boolean, input: CharSequence, context: Scan.Line_Context)
-    : (List[Token], Scan.Line_Context) =
-  {
+  def tokenize_line(
+    SML: Boolean,
+    input: CharSequence,
+    context: Scan.Line_Context
+  ) : (List[Token], Scan.Line_Context) = {
     var in: Reader[Char] = Scan.char_reader(input)
     val toks = new mutable.ListBuffer[Token]
     var ctxt = context
     while (!in.atEnd) {
       Parsers.parse(Parsers.token_line(SML, ctxt), in) match {