src/Tools/VSCode/src/server.scala

 
 object Server
 {
   /* Isabelle tool wrapper */
 
-  private val default_text_length = "UTF-16"
   private lazy val default_logic = Isabelle_System.getenv("ISABELLE_LOGIC")
 
   val isabelle_tool = Isabelle_Tool("vscode_server", "VSCode Language Server for PIDE", args =>
   {
     try {
       var log_file: Option[Path] = None
-      var text_length = Text.Length.encoding(default_text_length)
       var dirs: List[Path] = Nil
       var logic = default_logic
       var modes: List[String] = Nil
       var options = Options.init()
       var system_mode = false
 
-      def text_length_choice: String =
-        commas(Text.Length.encodings.map(
-          { case (a, _) => if (a == default_text_length) a + " (default)" else a }))
-
       val getopts = Getopts("""
 Usage: isabelle vscode_server [OPTIONS]
 
   Options are:
     -L FILE      enable logging on FILE
-    -T LENGTH    text length encoding: """ + text_length_choice + """
     -d DIR       include session directory
     -l NAME      logic session name (default ISABELLE_LOGIC=""" + quote(default_logic) + """)
     -m MODE      add print mode for output
     -o OPTION    override Isabelle system OPTION (via NAME=VAL or NAME)
     -s           system build mode for session image
 
   Run the VSCode Language Server protocol (JSON RPC) over stdin/stdout.
 """,
         "L:" -> (arg => log_file = Some(Path.explode(File.standard_path(arg)))),
-        "T:" -> (arg => Text.Length.encoding(arg)),
         "d:" -> (arg => dirs = dirs ::: List(Path.explode(File.standard_path(arg)))),
         "l:" -> (arg => logic = arg),
         "m:" -> (arg => modes = arg :: modes),
         "o:" -> (arg => options = options + arg),
         "s" -> (_ => system_mode = true))

       val more_args = getopts(args)
       if (more_args.nonEmpty) getopts.usage()
 
       val log = Logger.make(log_file)
       val channel = new Channel(System.in, System.out, log)
-      val server = new Server(channel, options, text_length, logic, dirs, modes, system_mode, log)
+      val server = new Server(channel, options, logic, dirs, modes, system_mode, log)
 
       // prevent spurious garbage on the main protocol channel
       val orig_out = System.out
       try {
         System.setOut(new PrintStream(new OutputStream { def write(n: Int) {} }))

 }
 
 class Server(
   val channel: Channel,
   options: Options,
-  text_length: Text.Length = Text.Length.encoding(Server.default_text_length),
   session_name: String = Server.default_logic,
   session_dirs: List[Path] = Nil,
   modes: List[String] = Nil,
   system_mode: Boolean = false,
   log: Logger = No_Logger)

             progress.echo(fail_msg); error(fail_msg)
           }
         }
 
         val base = Build.session_base(options, false, session_dirs, session_name)
-        val resources =
-          new VSCode_Resources(options, text_length, base, log)
+        val resources = new VSCode_Resources(options, base, log)
           {
             override def commit(change: Session.Change): Unit =
               if (change.deps_changed || undefined_blobs(change.version.nodes).nonEmpty)
                 delay_load.invoke()
           }