src/Pure/Tools/server.scala

 /*  Title:      Pure/Tools/server.scala
     Author:     Makarius
 
 Resident Isabelle servers.
+
+Message formats:
+
+  - short message (single line):
+      NAME ARGUMENT
+
+  - long message (multiple lines):
+      BYTE_LENGTH
+      NAME ARGUMENT
 */
 
 package isabelle
 
 

 
 object Server
 {
   /* protocol */
 
-  def split_line(line: String): (String, String) =
-  {
-    val head = line.takeWhile(c => Symbol.is_ascii_letter(c) || Symbol.is_ascii_letdig(c))
-    val rest = line.substring(head.length).dropWhile(Symbol.is_ascii_blank(_))
+  def split_message(msg: String): (String, String) =
+  {
+    val head = msg.takeWhile(c => Symbol.is_ascii_letter(c) || Symbol.is_ascii_letdig(c))
+    val rest = msg.substring(head.length).dropWhile(Symbol.is_ascii_blank(_))
     (head, proper_string(rest) getOrElse "{}")
   }
 
   val commands: Map[String, PartialFunction[(Server, JSON.T), JSON.T]] =
     Map(

 
   object Reply extends Enumeration
   {
     val OK, ERROR, NOTE = Value
 
-    def unapply(line: String): Option[(Reply.Value, JSON.T)] =
-    {
-      if (line == "") None
+    def unapply(msg: String): Option[(Reply.Value, JSON.T)] =
+    {
+      if (msg == "") None
       else {
-        val (reply, output) = split_line(line)
+        val (reply, output) = split_message(msg)
         try { Some((withName(reply), JSON.parse(output, strict = false))) }
         catch {
           case _: NoSuchElementException => None
           case Exn.ERROR(_) => None
         }

     def close() { socket.close }
 
     val in = new BufferedInputStream(socket.getInputStream)
     val out = new BufferedOutputStream(socket.getOutputStream)
 
-    def read_line(): Option[String] =
-      try { Bytes.read_line(in).map(_.text) }
+    def read_message(): Option[String] =
+      try {
+        Bytes.read_line(in).map(_.text) match {
+          case Some(Value.Int(n)) =>
+            Bytes.read_block(in, n).map(bytes => Library.trim_line(bytes.text))
+          case res => res
+        }
+      }
       catch { case _: SocketException => None }
 
-    def write_line(msg: String)
-    {
-      require(split_lines(msg).length <= 1)
-      out.write(UTF8.bytes(msg))
+    def write_message(msg: String)
+    {
+      val b = UTF8.bytes(msg)
+      if (b.length > 100 || b.contains(10)) {
+        out.write(UTF8.bytes((b.length + 1).toString))
+        out.write(10)
+      }
+      out.write(b)
       out.write(10)
       try { out.flush() } catch { case _: SocketException => }
     }
 
     def reply(r: Server.Reply.Value, t: JSON.T)
     {
-      write_line(if (t == JSON.empty) r.toString else r.toString + " " + JSON.Format(t))
+      write_message(if (t == JSON.empty) r.toString else r.toString + " " + JSON.Format(t))
     }
 
     def reply_ok(t: JSON.T) { reply(Server.Reply.OK, t) }
     def reply_error(t: JSON.T) { reply(Server.Reply.ERROR, t) }
     def reply_error_message(message: String, more: (String, JSON.T)*): Unit =

       "server " + quote(name) + " = " + print(port, password)
 
     def connection(): Connection =
     {
       val connection = Connection(new Socket(InetAddress.getByName("127.0.0.1"), port))
-      connection.write_line(password)
+      connection.write_message(password)
       connection
     }
 
     def active(): Boolean =
       try {
         using(connection())(connection =>
           {
             connection.socket.setSoTimeout(2000)
-            connection.read_line() == Some(Reply.OK.toString)
+            connection.read_message() == Some(Reply.OK.toString)
           })
       }
       catch {
         case _: IOException => false
         case _: SocketException => false

   {
     using(SQLite.open_database(Data.database))(db =>
       db.transaction {
         find(db, name) match {
           case Some(server_info) =>
-            using(server_info.connection())(_.write_line("shutdown"))
+            using(server_info.connection())(_.write_message("shutdown"))
             while(server_info.active) { Thread.sleep(50) }
             true
           case None => false
         }
       })

 
   override def toString: String = Server.print(port, password)
 
   private def handle(connection: Server.Connection)
   {
-    connection.read_line() match {
-      case Some(line) if line == password =>
+    connection.read_message() match {
+      case Some(msg) if msg == password =>
         connection.reply_ok(JSON.empty)
         var finished = false
         while (!finished) {
-          connection.read_line() match {
+          connection.read_message() match {
             case None => finished = true
             case Some("") =>
               connection.notify_message("Command 'help' provides list of commands")
-            case Some(line) =>
-              val (cmd, input) = Server.split_line(line)
+            case Some(msg) =>
+              val (cmd, input) = Server.split_message(msg)
               Server.commands.get(cmd) match {
                 case None => connection.reply_error("Bad command " + quote(cmd))
                 case Some(body) =>
                   input match {
                     case JSON.Format(arg) =>

                         connection.reply_error_message(
                           "Bad argument for command", "command" -> cmd, "argument" -> arg)
                       }
                     case _ =>
                       connection.reply_error_message(
-                        "Malformed command-line", "command" -> cmd, "input" -> input)
+                        "Malformed message", "command" -> cmd, "input" -> input)
                   }
               }
           }
         }
       case _ =>