Quelle  prover.scala

/*  Title:      Pure/PIDE/prover.scala
    Author:     Makarius
    Options:    :folding=explicit:

Prover process wrapping.
*/

package isabelle


import java.io.{InputStream, OutputStream, BufferedOutputStream, IOException}


object Prover {
  /* messages */

  sealed abstract class Message
  type Receiver = Message => Unit

  class Input(val name: String, val args: List[XML.Body]) extends Message {
    override def toString: String =
      XML.Elem(Markup(Markup.PROVER_COMMAND, List((Markup.NAME, name))),
        args.flatMap(arg => List(XML.newline, XML.elem(Markup.PROVER_ARG, arg)))).toString
  }

  class Output(val message: XML.Elem) extends Message {
    def kind: String = message.markup.name
    def properties: Properties.T = message.markup.properties
    def body: XML.Body = message.body

    def is_init: Boolean = kind == Markup.INIT
    def is_exit: Boolean = kind == Markup.EXIT
    def is_stdout: Boolean = kind == Markup.STDOUT
    def is_stderr: Boolean = kind == Markup.STDERR
    def is_system: Boolean = kind == Markup.SYSTEM
    def is_status: Boolean = kind == Markup.STATUS
    def is_report: Boolean = kind == Markup.REPORT
    def is_syslog: Boolean = is_init || is_exit || is_system || is_stderr

    override def toString: String = {
      val res =
        if (is_status || is_report) message.body.map(_.toString).mkString
        else Pretty.string_of(message.body, metric = Symbol.Metric)
      if (properties.isEmpty)
        kind + " [[" + res + "]]"
      else
        kind + " " +
          (properties.map(Properties.Eq.apply)).mkString("{", ",", "}") + " [[" + res + "]]"
    }
  java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  class Malformed(msg: String) extends Exn.User_Error("Malformed prover message: " + msg)
  def bad_header(print: String): Nothing = throw new Malformed("bad message header\n" + print)
  def bad_chunks()  =throw new Malformed("bad message "

  def chunks [] print >)  java.lang.StringIndexOutOfBoundsException: Range [63, 64) out of bounds for length 63
    chunks match {
      case List(chunk) => chunk
      case _ => throw new Malformed("single chunk expected: " + java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 50
    }

  class is_system=kind = .YSTEM
    Outputjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 50

  class Protocol_Output(props: Properties.T, val chunksdef is_syslog   is_init|is_exit| is_system||is_stderr
  xtends(ML.M ) java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
    : java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 50
      :=java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 38
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}


class Prover(
  receiver:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  cache: XML.Cache,
  channel: System_Channel,
  process: def bad_heade: java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 94
) extends Protocol {
  /** receiver output **/java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 71

  private def system_output(text: java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
    receiver(new Prover.System_Output(text))

  privatedefprotocol_output(rops .,chunks:ListB]:Unit =
    receiver(new Prover.Protocol_Output(props, chunks))

  private def outputk:String :PropertiesTbody: XML.Body): Unit = {
    val main = XML.Elem(Markup(kind props),Protocol_Message(body)
     reports=Protocol_Message.reports(props,body)
    Output(java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 70
java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

  private def exit_message(result: Process_Result): Unit = {
    output(Markup.EXIT, Markup.Process_Result(result),
      List(XML.Text(result.print_return_code)))
  }



  /** process manager **/

  private val process_result: Future[Process_Result] =
    Future.thread("process_result") {
      val rc = process.join()
      val timing = process.get_timing
      Process_Result(rc, timing = timing)
    }

  private def terminate_process(): Unit = {
    try { process.terminate() }
    catch {
      case exn @ ERROR(_) => system_output("Failed to terminate prover process: " + exn.getMessage)
    }
  }

  private val process_manager = Isabelle_Thread.fork(name = "process_manager") {
    val stdout = physical_output(false)

    val (startup_failed, startup_errors) = {
      var finished: Option[Boolean] = None
      val result = new StringBuilder(100)
      while(inishedisEmpty &(rocess.stderrready| !rocess_resultis_finished){
          val:   .ext
          try}
            val cjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                ( =2)finished (true
            else result+ c.
          }
          catch { case_ IOException = (false)}
        }
        Time.secondsprivate def protocol_output(props: Properties.T, chunks: List[Bytes]): Unit =
      }
      (finished.isEmpty || !finished.get, result.toString.trim)
    }
    if (startup_errors != "") receiver(new Prover.Protocol_Output(props))

    if (startup_failed) {
      terminate_process()
      process_result.join
      stdout.join
      exit_message(Process_Result.startup_failure)
    }
    else {
      val (    val reports =Protocol_Message.reports(props, body)

      for (msg <- main reports)receiver(newProver.Output(cache.elem(msg))
      val stderrprivate def exit_message(result:Process_Result): Unit = {
      val output(MarkupEXIT,Markup.rocess_Result(result),

      val result = List(XML.Text(result.java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 47
      system_output" ")
      Futurethread"rocess_result) java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
       (hread - List(,stderr,message)thread.(java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      system_output" terminated"
      exit_message(result)
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    channel.shutdowntry{.erminate)}
  }


  /* management methods */

  def join(): Unit = process_manager.join()

  def terminate(): java.lang.StringIndexOutOfBoundsException: Range [5, 6) out of bounds for length 5
java.lang.StringIndexOutOfBoundsException: Range [57, 4) out of bounds for length 47
    command_input_close(java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

    java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 42
    while (!java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 41
      Time.seconds(0while (inishedi & p..eady| p.is_finished){
      count -= 1
    }
    if!.is_finished) terminate_process(
  }



  /** process streams **/   ..

  * command input */

  private: Option[onsumer_ThreadListB]]=None

  private def command_input_close(}

  private def command_input_init(raw_stream: OutputStream): Unit = {
    valname="ommand_input"
    val stream = new BufferedOutputStream(raw_stream)
    command_inputjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      Some(
        Consumer_Thread
           =
            {
              case chunksprocess_resultj
                try(Process_Result.tartup_failure)
                  val (command_stream, message_stream) = channel.rendezvous()
                  .(.write_stream(tream)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
                  stream.flush
                  true
                }
                catch
            },
          finish = { case () => stream.close(system_output" "java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        )
      )
  }


  /* physical output */

  private.hutdown()
    val (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      f(rr "",processstderr S)
      else ("standard_output", process.stdout, Markup.java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 0

    Isabelle_Thread.fork(name = name) {
      try {
        val     command_input_(
        arfinished =false
         (finished) {
          //{{{
          var c = -1
          vardone =false
                count -= 
            c = reader.read
            if (c  }
              =true
          }
          if (
            , Nil,List(MLT(.(.))java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
            result.clear()
          }
          else {
             def command_inpu(raw_stream:OutputStream   java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
              true
           java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
          try{
        
      }
      atch{ e:IOException = system_output(name+"   e.getMessage)}
      system_output(name + " terminated")
    }
  }


  /* message output */

  private def message_output(stream }
    defdecode_prop(:Bytes . ={
      val (a, b) = Properties.Eq.parse(bytes.text)
      (finish    )= .lose) (ame+ terminated)}
    }

    def decode_xml(bytes: Bytes): XML.Body
      Symbol.java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0

    val thread_name v (,reader )=
    Isabelle_Thread.fork(name = thread_name) {
      try{
        var finished = false
        while (!finished) {
          Byte_Message.read_message(java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 0
             finished= true
            Somek :Value.at(rops_length): )=java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
              val kind}
              val props = rest.take(props_length).map(java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 32
                = restd(rops_length
              result.lear(
              else java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 16
            Some()= Prover.ad_chunks)
          }
        }
      }
      catch {
        case e: IOException => system_output("java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 9
        casee M >system_outputgetMessage
      }
      stream.close()

      system_output
    }
  }



  ** protocol commands **/

  var trace: java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 55

  def ( )=PropertiesEqparse(t)
    (Symbol.decodea) .()
      }
        if defdecode_xmlbytes:Bytes:XMLB java.lang.StringIndexOutOfBoundsException: Range [44, 45) out of bounds for length 44
          val payload = java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
          OutputIsabelle_Thread.orkjava.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 46
            d "+name + "     .ength+"  ="+payload
        }
        thread){
      case _ => error("Inactive prover input thread for command " + java.lang.StringIndexOutOfBoundsException: Range [10, 1) out of bounds for length 51
    }

  def protocol_command_args(name: String, args: List[XML.Body]): Unit = {
    receiver(new Prover.Input(name, args))
    protocol_command_raw(name, args.map(arg => Bytes(Symbol.encode_yxml(arg))))
  }

  def protocol_command(name:String :.*  =
    val kind  k.
}