(*  Title:      Watcher.ML

    ID:         $Id$

    Author:     Claire Quigley

    Copyright   2004  University of Cambridge

 *)

 (***************************************************************************)

 (*  The watcher process starts a resolution process when it receives a     *)

(*  message from Isabelle                                                  *)

(*  Signals Isabelle, puts output of child into pipe to Isabelle,          *)

(*  and removes dead processes.  Also possible to kill all the resolution  *)

(*  processes currently running.                                           *)

(*  Hardwired version of where to pick up the tptp files for the moment    *)

(***************************************************************************)

(*use "Proof_Transfer";

use "VampireCommunication";

use "SpassCommunication";*)

(*use "/homes/clq20/Jia_Code/TransStartIsar";*)

structure Watcher: WATCHER =

  struct

open ReconPrelim Recon_Transfer

val goals_being_watched = ref 0;

(*****************************************)

(*  The result of calling createWatcher  *)

(*****************************************)

datatype proc = PROC of {

        pid : Posix.Process.pid,

        instr : TextIO.instream,

        outstr : TextIO.outstream

      };

(*****************************************)

(*  The result of calling executeToList  *)

(*****************************************)

datatype cmdproc = CMDPROC of {

        prover: string,             (* Name of the resolution prover used, e.g. Vampire, SPASS *)

        cmd:  string,              (* The file containing the goal for res prover to prove *)     

        thmstring: string,         (* string representation of subgoal after negation, skolemization*) 

        goalstring: string,         (* string representation of subgoal*) 

        proc_handle : (TextIO.instream,TextIO.outstream) Unix.proc,

        instr : TextIO.instream,   (*  Input stream to child process *)

        outstr : TextIO.outstream  (*  Output stream from child process *)

      };

type signal = Posix.Signal.signal

datatype exit_status = datatype Posix.Process.exit_status

val fromStatus = Posix.Process.fromStatus

fun reap(pid, instr, outstr) =

        let

		val u = TextIO.closeIn instr;

	        val u = TextIO.closeOut outstr;

		val (_, status) =

			Posix.Process.waitpid(Posix.Process.W_CHILD pid, [])

	in

		status

	end

fun fdReader (name : string, fd : Posix.IO.file_desc) =

	  Posix.IO.mkTextReader {initBlkMode = true,name = name,fd = fd };

fun fdWriter (name, fd) =

          Posix.IO.mkTextWriter {

	      appendMode = false,

              initBlkMode = true,

              name = name,  

              chunkSize=4096,

              fd = fd

            };

fun openOutFD (name, fd) =

	  TextIO.mkOutstream (

	    TextIO.StreamIO.mkOutstream (

	      fdWriter (name, fd), IO.BLOCK_BUF));

fun openInFD (name, fd) =

	  TextIO.mkInstream (

	    TextIO.StreamIO.mkInstream (

	      fdReader (name, fd), ""));

fun killChild child_handle = Unix.reap child_handle 

fun childInfo (PROC{pid,instr,outstr }) = (pid,(instr,outstr));

fun cmdstreamsOf (CMDPROC{instr,outstr,...}) = (instr, outstr);

fun cmdInStream (CMDPROC{instr,outstr,...}) = (instr);

fun cmdchildInfo (CMDPROC{prover,cmd,thmstring,proc_handle,goalstring,instr,outstr}) = (prover,(cmd, (instr,outstr)));

fun cmdchildHandle (CMDPROC{prover,cmd,thmstring,goalstring,proc_handle,instr,outstr})  = proc_handle;

fun cmdProver (CMDPROC{prover,cmd,thmstring,goalstring,proc_handle,instr,outstr})  = (prover);

fun cmdThm (CMDPROC{prover,cmd,thmstring,goalstring,proc_handle,instr,outstr})  = (thmstring);

fun cmdGoal (CMDPROC{prover,cmd,thmstring,goalstring,proc_handle,instr,outstr})  = (goalstring);

fun sendOutput (outstr,str) = (TextIO.outputSubstr (outstr, (Substring.all str));TextIO.flushOut outstr);

(********************************************************************************************)

(*  takes a list of arguments and sends them individually to the watcher process by pipe    *)

(********************************************************************************************)

fun outputArgs (toWatcherStr, []) = ()

|   outputArgs (toWatcherStr, (x::xs)) = (TextIO.output (toWatcherStr, x); 

                                          TextIO.flushOut toWatcherStr;

                                         outputArgs (toWatcherStr, xs))

(********************************************************************************)

(*    gets individual args from instream and concatenates them into a list      *)

(********************************************************************************)

fun getArgs (fromParentStr, toParentStr,ys) =  let 

                                       val thisLine = TextIO.input fromParentStr

                                    in

                                        ((ys@[thisLine]))

                                    end

(********************************************************************************)

(*  Remove the \n character from the end of each filename                       *)

(********************************************************************************)

(*fun getCmd cmdStr = let val backList = ((rev(explode cmdStr))) 

                    in

                        if (String.isPrefix "\n"  (implode backList )) 

                        then (implode (rev ((tl backList))))

                        else cmdStr

                    end*)

(********************************************************************************)

(*  Send request to Watcher for a vampire to be called for filename in arg      *)

(********************************************************************************)

fun callResProver (toWatcherStr,  arg) = (sendOutput (toWatcherStr, arg^"\n"); 

                                     TextIO.flushOut toWatcherStr)

(*****************************************************************************************)

(*  Send request to Watcher for multiple provers to be called for filenames in arg       *)

(*  need to do the dfg stuff in the watcher, not here! send over the clasimp and stuff files too*)

(*****************************************************************************************)

(* need to modify to send over hyps file too *)

fun callResProvers (toWatcherStr,  []) = 

      (sendOutput (toWatcherStr, "End of calls\n");  TextIO.flushOut toWatcherStr)

|   callResProvers (toWatcherStr,

                    (prover,thmstring,goalstring, proverCmd,settings,clasimpfile, 

                     axfile, hypsfile,probfile)  ::  args) =

      let val _ = File.write (File.tmp_path (Path.basic "tog_comms"))

                             (prover^thmstring^goalstring^proverCmd^settings^

                              clasimpfile^hypsfile^probfile)

      in sendOutput (toWatcherStr,    

            (prover^"$"^thmstring^"$"^goalstring^"$"^proverCmd^"$"^

             settings^"$"^clasimpfile^"$"^hypsfile^"$"^probfile^"\n"));

         goals_being_watched := (!goals_being_watched) + 1;

	 TextIO.flushOut toWatcherStr;

	 callResProvers (toWatcherStr,args)

      end   

(*

fun callResProversStr (toWatcherStr,  []) =  "End of calls\n" 

|   callResProversStr (toWatcherStr,(prover,thmstring,goalstring, proverCmd,settings,clasimpfile, axfile, hypsfile, probfile)::args) =

                                            ((prover^"*"^thmstring^"*"^goalstring^"*"^proverCmd^"*"^settings^"*"^clasimpfile^"*"^axfile^"*"^hypsfile^"*"^probfile^"\n")

     *)                                      

(**************************************************************)

(* Send message to watcher to kill currently running vampires *)

(**************************************************************)

fun callSlayer (toWatcherStr) = (sendOutput (toWatcherStr, "Kill vampires\n"); 

                            TextIO.flushOut toWatcherStr)

(**************************************************************)

(* Remove \n token from a vampire goal filename and extract   *)

(* prover, proverCmd, settings and file from input string     *)

(**************************************************************)

 fun takeUntil ch [] res  = (res, [])

 |   takeUntil ch (x::xs) res = 

        if   x = ch then (res, xs)

	else takeUntil ch xs (res@[x])

 fun getSettings [] settings = settings

|    getSettings (xs) settings = 

       let val (set, rest ) = takeUntil "%" xs []

       in

	   getSettings rest (settings@[(implode set)])

       end

fun separateFields str =

  let val  outfile = TextIO.openAppend(*("sep_field")*)(File.platform_path(File.tmp_path (Path.basic "sep_field")))                                                                         

      val _ = TextIO.output (outfile,("In separateFields, str is: "^(implode str)^"\n\n") )

      val _ =  TextIO.closeOut outfile

      val (prover, rest) = takeUntil "$" str []

      val prover = implode prover

      val (thmstring, rest) =  takeUntil "$" rest []

      val thmstring = implode thmstring

      val (goalstring, rest) =  takeUntil "$" rest []

      val goalstring = implode goalstring

      val (proverCmd, rest ) =  takeUntil "$" rest []

      val proverCmd = implode proverCmd

      val (settings, rest) =  takeUntil "$" rest []

      val settings = getSettings settings []

      val (clasimpfile, rest ) =  takeUntil "$" rest []

      val clasimpfile = implode clasimpfile

      val (hypsfile, rest ) =  takeUntil "$" rest []

      val hypsfile = implode hypsfile

      val (file, rest) =  takeUntil "$" rest []

      val file = implode file

      val _ = File.append (File.tmp_path (Path.basic "sep_comms"))                                                                                

                  ("Sep comms are: "^(implode str)^"**"^

                   prover^" thmstring: "^thmstring^"\n goalstr:  "^goalstring^" \n provercmd: "^proverCmd^" \n  clasimp "^clasimpfile^" \n hyps "^hypsfile^"\n prob  "^file^"\n\n")

  in

     (prover,thmstring,goalstring, proverCmd, settings, clasimpfile, hypsfile, file)

  end

(***********************************************************************************)

(* do tptp2x and cat to turn clasimpfile, hypsfile and probfile into one .dfg file *)

(***********************************************************************************)

fun formatCmd (prover,thmstring,goalstring, proverCmd, settings, clasimpfile, hypsfile ,probfile) = 

  let

    (*** want to cat clasimp ax hyps prob, then send the resulting file to tptp2x ***)

    val probID = List.last(explode probfile)

    val wholefile = File.tmp_path (Path.basic ("ax_prob_" ^ probID))

    (*** only include problem and clasimp for the moment, not sure 

	 how to refer to hyps/local axioms just now ***)

    val whole_prob_file = Unix.execute("/bin/cat", 

	     [clasimpfile,(*axfile, hypsfile,*)probfile,  ">",

	      File.platform_path wholefile])

    val dfg_dir = File.tmp_path (Path.basic "dfg"); 

    val dfg_path = File.platform_path dfg_dir;

    (*** want to cat clasimp ax hyps prob, then send the resulting file to tptp2x ***)

    val probID = List.last(explode probfile)

    val wholefile = File.tmp_path (Path.basic ("ax_prob_"^probID))

    (*** only include problem and clasimp for the moment, not sure how to refer to ***)

    (*** hyps/local axioms just now                                                ***)

    val whole_prob_file = Unix.execute("/bin/cat", [clasimpfile,(*axfile, hypsfile,*)probfile,  ">", (File.platform_path wholefile)])

    (*** check if the directory exists and, if not, create it***)

   (* val _ = 

	if !SpassComm.spass

	then 

	    if File.exists dfg_dir then warning("dfg dir exists")

	    else File.mkdir dfg_dir

	else

	    warning("not converting to dfg")

    val _ = if !SpassComm.spass then 

		system (ResLib.helper_path "TPTP2X_HOME" "tptp2X" ^ 

		        " -fdfg -d " ^ dfg_path ^ " " ^

			File.platform_path wholefile)

	      else 7

    val newfile =   if !SpassComm.spass 

		    then 

			    dfg_path^"/ax_prob"^"_"^(probID)^".dfg" 

		    else

			    (File.platform_path wholefile)*)

    (* if using spass prob_n already contains whole DFG file, otherwise need to mash axioms*)

    (* from clasimpset onto problem file *)

    val newfile =   if !SpassComm.spass 

		    then 

			 probfile

                    else 

			(File.platform_path wholefile)

    val _ =  File.append (File.tmp_path (Path.basic"thmstring_in_watcher"))

	       (thmstring^"\n goals_watched"^(string_of_int(!goals_being_watched))^newfile^"\n")

  in

    (prover,thmstring,goalstring, proverCmd, settings,newfile)	

  end;

(* remove \n from end of command and put back into tuple format *)

(*  val cmdStr = "spass*((ALL xa. (~ P x | P xa) & (~ P xa | P x)) & (P xa | (ALL x. P x)) & ((ALL x. ~ P x) | ~ P xb) [.])*(EX x. ALL y. P x = P y) --> (EX x. P x) = (ALL y. P y)*/homes/clq20/bin/SPASS*-DocProof*/local/scratch/clq20/27023/clasimp*/local/scratch/clq20/27023/hyps*/local/scratch/clq20/27023/prob_1\n"

val cmdStr = "vampire*(length (rev xs) = length xs  [.]) & (length (rev (a # xs)) ~= length (a # xs) [.])*length (rev []) = length []*/homes/jm318/Vampire8/vkernel*-t 300%-m 100000*/local/scratch/clq20/23523/clasimp*/local/scratch/clq20/23523/hyps*/local/scratch/clq20/23523/prob_1\n"

 *)

(*FIX:  are the two getCmd procs getting confused?  Why do I have two anyway? *)

 fun getCmd cmdStr = 

       let val backList = rev(explode cmdStr)

	   val _ = File.append (File.tmp_path (Path.basic"cmdStr")) cmdStr

       in

	   if (String.isPrefix "\n"  (implode backList )) 

	   then 

	       let val newCmdStr = (rev(tl backList))

	       in  File.write (File.tmp_path (Path.basic"backlist")) 

	                      ("about to call sepfields with "^(implode newCmdStr));

		   formatCmd (separateFields newCmdStr)

	       end

	   else formatCmd (separateFields (explode cmdStr))

       end

fun getProofCmd (a,b,c,d,e,f) = d

(**************************************************************)

(* Get commands from Isabelle                                 *)

(**************************************************************)

(* FIX: or perhaps do the tptp2x stuff here - so it's get commands and then format them, before passing them to spass *)

fun getCmds (toParentStr,fromParentStr, cmdList) = 

  let val thisLine = TextIO.inputLine fromParentStr 

      val _ = File.append (File.tmp_path (Path.basic "parent_comms")) thisLine

  in

     if (thisLine = "End of calls\n") 

     then cmdList

     else if (thisLine = "Kill children\n") 

     then 

	 (   TextIO.output (toParentStr,thisLine ); 

	     TextIO.flushOut toParentStr;

	   (("","","","Kill children",[],"")::cmdList)

	  )

     else  let val thisCmd = getCmd (thisLine) 

	       (*********************************************************)

	       (* thisCmd = (prover,thmstring,proverCmd, settings, file)*)

	       (* i.e. put back into tuple format                       *)

	       (*********************************************************)

	   in

	     (*TextIO.output (toParentStr, thisCmd); 

	       TextIO.flushOut toParentStr;*)

	       getCmds (toParentStr,fromParentStr, (thisCmd::cmdList))

	   end

  end

(**************************************************************)

(*  Get Io-descriptor for polling of an input stream          *)

(**************************************************************)

fun getInIoDesc someInstr = 

    let val (rd, buf) = TextIO.StreamIO.getReader(TextIO.getInstream someInstr)

        val _ = TextIO.output (TextIO.stdOut, buf)

        val ioDesc = 

	    case rd

	      of TextPrimIO.RD{ioDesc = SOME iod, ...} =>SOME iod

	       | _ => NONE

     in (* since getting the reader will have terminated the stream, we need

	 * to build a new stream. *)

	TextIO.setInstream(someInstr, TextIO.StreamIO.mkInstream(rd, buf));

	ioDesc

    end

(*************************************)

(*  Set up a Watcher Process         *)

(*************************************)

fun setupWatcher (thm,clause_arr, num_of_clauses) = 

  let

    (** pipes for communication between parent and watcher **)

    val p1 = Posix.IO.pipe ()

    val p2 = Posix.IO.pipe ()

    fun closep () = (

	  Posix.IO.close (#outfd p1); 

	  Posix.IO.close (#infd p1);

	  Posix.IO.close (#outfd p2); 

	  Posix.IO.close (#infd p2)

	)

    (***********************************************************)

    (****** fork a watcher process and get it set up and going *)

    (***********************************************************)

    fun startWatcher (procList) =

	     (case  Posix.Process.fork() (***************************************)

	   of SOME pid =>  pid           (* parent - i.e. main Isabelle process *)

					 (***************************************)

					   (*************************)

	    | NONE => let                  (* child - i.e. watcher  *)

		val oldchildin = #infd p1  (*************************)

		val fromParent = Posix.FileSys.wordToFD 0w0

		val oldchildout = #outfd p2

		val toParent = Posix.FileSys.wordToFD 0w1

		val fromParentIOD = Posix.FileSys.fdToIOD fromParent

		val fromParentStr = openInFD ("_exec_in_parent", fromParent)

		val toParentStr = openOutFD ("_exec_out_parent", toParent)

		val sign = sign_of_thm thm

		val prems = prems_of thm

		val prems_string =  Meson.concat_with_and (map (Sign.string_of_term sign) prems) 

		val _ = (warning ("subgoals forked to startWatcher: "^prems_string));

	       (* tracing *)

	      (*val tenth_ax = fst( Array.sub(clause_arr, 1))  

		val tenth_ax_thms = memo_find_clause (tenth_ax, clause_tab)

		val clause_str = Meson.concat_with_and (map string_of_thm tenth_ax_thms)

		val _ = (warning ("tenth axiom in array in watcher is: "^tenth_ax))         

		val _ = (warning ("tenth axiom in table in watcher is: "^clause_str))         

		val _ = (warning ("num_of_clauses in watcher is: "^(string_of_int (num_of_clauses))) )       

			 *)

		(*val goalstr = string_of_thm (the_goal)

		 val  outfile = TextIO.openOut(File.platform_path(File.tmp_path (Path.basic "goal_in_watcher")));  

		val _ = TextIO.output (outfile,goalstr )

		val _ =  TextIO.closeOut outfile*)

		fun killChildren [] = ()

	     |      killChildren  (child_handle::children) = (killChild child_handle; killChildren children)

	      (*************************************************************)

	      (* take an instream and poll its underlying reader for input *)

	      (*************************************************************)

	      fun pollParentInput () = 

		 let val pd = OS.IO.pollDesc (fromParentIOD)

		 in 

		   if (isSome pd ) then 

		       let val pd' = OS.IO.pollIn (valOf pd)

			   val pdl = OS.IO.poll ([pd'], SOME (Time.fromMilliseconds 2000)) 

			   val _ = File.append (File.tmp_path (Path.basic "parent_poll")) 

			     ("In parent_poll\n")	

		       in

			  if null pdl 

			  then

			     NONE

			  else if (OS.IO.isIn (hd pdl)) 

			       then

				  (SOME ( getCmds (toParentStr, fromParentStr, [])))

			       else

				   NONE

		       end

		     else

			 NONE

		 end

	       fun pollChildInput (fromStr) = 

		 let val _ = File.append (File.tmp_path (Path.basic "child_poll")) 

			       ("In child_poll\n")

		     val iod = getInIoDesc fromStr

		 in 

		   if isSome iod 

		   then 

		     let val pd = OS.IO.pollDesc (valOf iod)

		     in 

		     if (isSome pd ) then 

			 let val pd' = OS.IO.pollIn (valOf pd)

			     val pdl = OS.IO.poll ([pd'], SOME (Time.fromMilliseconds 2000)) 

			 in

			    if null pdl 

			    then

			      ( File.append (File.tmp_path (Path.basic "child_poll_res")) 

			       ("Null pdl \n");NONE)

			    else if (OS.IO.isIn (hd pdl)) 

				 then

				     (let val inval =  (TextIO.inputLine fromStr)

					  val _ = File.append (File.tmp_path (Path.basic "child_poll_res")) (inval^"\n")

				      in

					    SOME inval

				      end)

				 else

				       ( File.append (File.tmp_path (Path.basic "child_poll_res")) 

			       ("Null pdl \n");NONE)

			 end

		       else  NONE

		       end

		   else NONE

	     end

	     (****************************************************************************)

	     (* Check all vampire processes currently running for output                 *)

	     (****************************************************************************) 

							(*********************************)

	      fun checkChildren ([], toParentStr) = []  (*** no children to check ********)

							(*********************************)

	      |   checkChildren ((childProc::otherChildren), toParentStr) = 

		    let val _ = File.append (File.tmp_path (Path.basic "child_check")) 

			           ("In check child, length of queue:"^(string_of_int (length (childProc::otherChildren)))^"\n")

                        val (childInput,childOutput) =  cmdstreamsOf childProc

			val child_handle= cmdchildHandle childProc

			(* childCmd is the .dfg file that the problem is in *)

			val childCmd = fst(snd (cmdchildInfo childProc))

                        val _ = File.append (File.tmp_path (Path.basic "child_command")) 

			           (childCmd^"\n")

			(* now get the number of the subgoal from the filename *)

			val sg_num = (*if (!SpassComm.spass )

				     then 

					int_of_string(ReconOrderClauses.get_nth 5 (rev(explode childCmd)))

				     else*)

					int_of_string(hd (rev(explode childCmd)))

			val childIncoming = pollChildInput childInput

 			val _ = File.append (File.tmp_path (Path.basic "child_check_polled")) 

			           ("finished polling child \n")

			val parentID = Posix.ProcEnv.getppid()

			val prover = cmdProver childProc

			val thmstring = cmdThm childProc

			val sign = sign_of_thm thm

			val prems = prems_of thm

			val prems_string =  Meson.concat_with_and (map (Sign.string_of_term sign) prems) 

			val _ = warning("subgoals forked to checkChildren: "^prems_string)

			val goalstring = cmdGoal childProc							

			val _ = File.append (File.tmp_path (Path.basic "child_comms")) 

			           (prover^thmstring^goalstring^childCmd^"\n")

		    in 

		      if (isSome childIncoming) 

		      then 

			  (* check here for prover label on child*)

			  let val _ = File.write (File.tmp_path (Path.basic "child_incoming"))  ("subgoals forked to checkChildren: "^prems_string^prover^thmstring^goalstring^childCmd) 

		              val childDone = (case prover of

	                          "vampire" => (VampComm.checkVampProofFound(childInput, toParentStr, parentID,thmstring,goalstring, childCmd, thm, sg_num,clause_arr, num_of_clauses) )                                              

                                 |"spass" => (SpassComm.checkSpassProofFound(childInput, toParentStr, parentID,thmstring,goalstring, childCmd, thm, sg_num,clause_arr, num_of_clauses)     ) )

			   in

			    if childDone      (**********************************************)

			    then (* child has found a proof and transferred it *)

			       (* Remove this child and go on to check others*)

			       (**********************************************)

			       (Unix.reap child_handle;

				checkChildren(otherChildren, toParentStr))

			    else 

			       (**********************************************)

			       (* Keep this child and go on to check others  *)

			       (**********************************************)

			      (childProc::(checkChildren (otherChildren, toParentStr)))

			 end

		       else

			 (File.append (File.tmp_path (Path.basic "child_incoming")) "No child output ";

			  childProc::(checkChildren (otherChildren, toParentStr)))

		    end

	  (********************************************************************)                  

	  (* call resolution processes                                        *)

	  (* settings should be a list of strings                             *)

	  (* e.g. ["-t 300", "-m 100000"]         (TextIO.input instr)^                            *)

	  (* takes list of (string, string, string list, string)list proclist *)

	  (********************************************************************)

(*** add subgoal id num to this *)

	     fun execCmds  [] procList = procList

	     |   execCmds  ((prover, thmstring,goalstring,proverCmd,settings,file)::cmds) procList  =             let val _ = File.append (File.tmp_path (Path.basic "pre_exec_child"))  ("\nAbout to execute command for goal:\n"^goalstring^proverCmd^(concat settings)^file^" at "^(Date.toString(Date.fromTimeLocal(Time.now()))))

	       in 

		 if (prover = "spass") 

		 then 

		   let val childhandle:(TextIO.instream,TextIO.outstream) Unix.proc  = 

		            (Unix.execute(proverCmd, (["-FullRed=0"]@settings@[file])))

		       val (instr, outstr) = Unix.streamsOf childhandle

		       val newProcList =    (((CMDPROC{

					    prover = prover,

					    cmd = file,

					    thmstring = thmstring,

					    goalstring = goalstring,

					    proc_handle = childhandle,

					    instr = instr,

					    outstr = outstr })::procList))

			val _ = File.append (File.tmp_path (Path.basic "exec_child"))  

			     ("\nexecuting command for goal:\n"^

			      goalstring^proverCmd^(concat settings)^file^" at "^(Date.toString(Date.fromTimeLocal(Time.now()))))

		   in

		      Posix.Process.sleep (Time.fromSeconds 1);execCmds cmds newProcList

		   end

		 else 

		   let val childhandle:(TextIO.instream,TextIO.outstream) Unix.proc  = 

		            (Unix.execute(proverCmd, (settings@[file])))

		       val (instr, outstr) = Unix.streamsOf childhandle

		       val newProcList = (CMDPROC{

					    prover = prover,

					    cmd = file,

					    thmstring = thmstring,

					    goalstring = goalstring,

					    proc_handle = childhandle,

					    instr = instr,

					    outstr = outstr }) :: procList

		       val _ = File.append (File.tmp_path (Path.basic "exec_child")) 

		                 ("executing command for goal:\n"^

		                  goalstring^proverCmd^(concat settings)^file^

		                  " at "^(Date.toString(Date.fromTimeLocal(Time.now()))))

		   in

		     Posix.Process.sleep (Time.fromSeconds 1); execCmds cmds newProcList

		   end

		end

	  (****************************************)                  

	  (* call resolution processes remotely   *)

	  (* settings should be a list of strings *)

	  (* e.g. ["-t 300", "-m 100000"]         *)

	  (****************************************)

	   (*  fun execRemoteCmds  [] procList = procList

	     |   execRemoteCmds ((prover, thmstring,goalstring,proverCmd ,settings,file)::cmds) procList  =  

				       let val  newProcList =  mySshExecuteToList ("/usr/bin/ssh",([prover,thmstring,goalstring,"-t", "shep"]@[proverCmd]@settings@[file]), procList)

					   in

						execRemoteCmds  cmds newProcList

					   end

*)

	     fun printList (outStr, []) = ()

	     |   printList (outStr, (x::xs)) = (TextIO.output (outStr, x);TextIO.flushOut outStr; printList (outStr,xs))                  

	  (**********************************************)                  

	  (* Watcher Loop                               *)

	  (**********************************************)

	      fun keepWatching (toParentStr, fromParentStr,procList) = 

		let fun loop (procList) =  

		     let val cmdsFromIsa = pollParentInput ()

			 fun killchildHandler (n:int)  = 

			       (TextIO.output(toParentStr, "Killing child proof processes!\n");

				TextIO.flushOut toParentStr;

				killChildren (map (cmdchildHandle) procList);

				())

		     in 

			(*Signal.signal (Posix.Signal.usr2, Signal.SIG_HANDLE killchildHandler);*)

									   (**********************************)

			if (isSome cmdsFromIsa) 

			then (*  deal with input from Isabelle *)

			  if (getProofCmd(hd(valOf cmdsFromIsa)) = "Kill children" )

			  then 

			    let val child_handles = map cmdchildHandle procList 

			    in

			       killChildren child_handles;

			       (*Posix.Process.kill(Posix.Process.K_PROC (Posix.ProcEnv.getppid()), Posix.Signal.usr2);*)    

			       loop ([])

			    end

			  else

			    if ((length procList)<10)    (********************)

			    then                        (* Execute locally  *)

			      let 

				val newProcList = execCmds (valOf cmdsFromIsa) procList

				val parentID = Posix.ProcEnv.getppid()

				   val _ = (File.append (File.tmp_path (Path.basic "prekeep_watch")) "Just execed a child\n ")

				val newProcList' =checkChildren (newProcList, toParentStr) 

				val _ = warning("off to keep watching...")

			       val _ = (File.append (File.tmp_path (Path.basic "keep_watch")) "Off to keep watching...\n ")

			      in

				(*Posix.Process.sleep (Time.fromSeconds 1);*)

				loop (newProcList') 

			      end

			    else  (* Execute remotely              *)

                                  (* (actually not remote for now )*)

			      let 

				val newProcList = execCmds (valOf cmdsFromIsa) procList

				val parentID = Posix.ProcEnv.getppid()

				val newProcList' =checkChildren (newProcList, toParentStr) 

			      in

				(*Posix.Process.sleep (Time.fromSeconds 1);*)

				loop (newProcList') 

			      end

			else (* No new input from Isabelle *)

			  let val newProcList = checkChildren ((procList), toParentStr)

			  in

			    (*Posix.Process.sleep (Time.fromSeconds 1);*)

			   (File.append (File.tmp_path (Path.basic "keep_watch")) "Off to keep watching.2..\n ");

			    loop (newProcList)

			  end

		      end

		in  

		    loop (procList)

		end

		in

		 (***************************)

		 (*** Sort out pipes ********)

		 (***************************)

		  Posix.IO.close (#outfd p1);

		  Posix.IO.close (#infd p2);

		  Posix.IO.dup2{old = oldchildin, new = fromParent};

		  Posix.IO.close oldchildin;

		  Posix.IO.dup2{old = oldchildout, new = toParent};

		  Posix.IO.close oldchildout;

		  (***************************)

		  (* start the watcher loop  *)

		  (***************************)

		  keepWatching (toParentStr, fromParentStr, procList);

		  (****************************************************************************)

		  (* fake return value - actually want the watcher to loop until killed       *)

		  (****************************************************************************)

		  Posix.Process.wordToPid 0w0

		end);

	  (* end case *)

    val _ = TextIO.flushOut TextIO.stdOut

    (*******************************)

    (***  set watcher going ********)

    (*******************************)

    val procList = []

    val pid = startWatcher (procList)

    (**************************************************)

    (* communication streams to watcher               *)

    (**************************************************)

    val instr = openInFD ("_exec_in", #infd p2)

    val outstr = openOutFD ("_exec_out", #outfd p1)

    in

     (*******************************)

     (* close the child-side fds    *)

     (*******************************)

      Posix.IO.close (#outfd p2);

      Posix.IO.close (#infd p1);

      (* set the fds close on exec *)

      Posix.IO.setfd (#infd p2, Posix.IO.FD.flags [Posix.IO.FD.cloexec]);

      Posix.IO.setfd (#outfd p1, Posix.IO.FD.flags [Posix.IO.FD.cloexec]);

     (*******************************)

     (* return value                *)

     (*******************************)

      PROC{pid = pid,

	instr = instr,

	outstr = outstr

      }

   end;

(**********************************************************)

(* Start a watcher and set up signal handlers             *)

(**********************************************************)

fun killWatcher pid= Posix.Process.kill(Posix.Process.K_PROC pid, Posix.Signal.kill);

fun reapWatcher(pid, instr, outstr) =

  let val u = TextIO.closeIn instr;

      val u = TextIO.closeOut outstr;

      val (_, status) = Posix.Process.waitpid(Posix.Process.W_CHILD pid, [])

  in

	  status

  end

fun createWatcher (thm,clause_arr, ( num_of_clauses:int)) =

 let val mychild = childInfo (setupWatcher(thm,clause_arr,  num_of_clauses))

     val streams =snd mychild

     val childin = fst streams

     val childout = snd streams

     val childpid = fst mychild

     val sign = sign_of_thm thm

     val prems = prems_of thm

     val prems_string =  Meson.concat_with_and (map (Sign.string_of_term sign) prems) 

     val _ = (warning ("subgoals forked to createWatcher: "^prems_string));

     fun vampire_proofHandler (n) =

	(Pretty.writeln(Pretty.str ( (concat[(oct_char "360"), (oct_char "377")])));

	 VampComm.getVampInput childin; Pretty.writeln(Pretty.str (oct_char "361")))               

     fun spass_proofHandler (n) = (

       let val  outfile = TextIO.openAppend(File.platform_path(File.tmp_path (Path.basic "foo_signal1")));

	   val _ = TextIO.output (outfile, ("In signal handler now\n"))

	   val _ =  TextIO.closeOut outfile

	   val (reconstr, goalstring, thmstring) = SpassComm.getSpassInput childin

	   val  outfile = TextIO.openAppend(File.platform_path(File.tmp_path (Path.basic "foo_signal")));

	   val _ = TextIO.output (outfile, ("In signal handler  "^reconstr^thmstring^goalstring^"goals_being_watched is: "^(string_of_int (!goals_being_watched))))

	   val _ =  TextIO.closeOut outfile

       in (* if a proof has been found and sent back as a reconstruction proof *)

	 if ( (substring (reconstr, 0,1))= "[")

	 then (Pretty.writeln(Pretty.str ( (concat[(oct_char "360"), (oct_char "377")])));

	       Recon_Transfer.apply_res_thm reconstr goalstring;

	       Pretty.writeln(Pretty.str  (oct_char "361"));

	       goals_being_watched := ((!goals_being_watched) - 1);

	       if ((!goals_being_watched) = 0)

	       then 

		  (let val  outfile = TextIO.openOut(File.platform_path(File.tmp_path (Path.basic "foo_reap_found")));

		       val _ = TextIO.output (outfile, ("Reaping a watcher, goals watched is: "^(string_of_int (!goals_being_watched))^"\n"))

		       val _ =  TextIO.closeOut outfile

		   in

		       killWatcher (childpid); reapWatcher (childpid,childin, childout); ()

		   end)

		else () )

	 (* if there's no proof, but a message from Spass *)

	 else if ((substring (reconstr, 0,5))= "SPASS")

	 then (goals_being_watched := (!goals_being_watched) -1;

	       Pretty.writeln(Pretty.str ( (concat[(oct_char "360"), (oct_char "377")])));

	       Pretty.writeln(Pretty.str ((Recon_Transfer.restore_linebreaks goalstring)^reconstr));

	       Pretty.writeln(Pretty.str  (oct_char "361"));

	       if (!goals_being_watched = 0)

	       then (File.write (File.tmp_path (Path.basic "foo_reap_comp"))

	              ("Reaping a watcher, goals watched is: " ^

	                 (string_of_int (!goals_being_watched))^"\n");

	             killWatcher (childpid); reapWatcher (childpid,childin, childout); ())

		else () ) 

	(* print out a list of rules used from clasimpset*)

	 else if ((substring (reconstr, 0,5))= "Rules")

	 then (goals_being_watched := (!goals_being_watched) -1;

	       Pretty.writeln(Pretty.str ( (concat[(oct_char "360"), (oct_char "377")])));

	       Pretty.writeln(Pretty.str (goalstring^reconstr));

	       Pretty.writeln(Pretty.str  (oct_char "361"));

	       if (!goals_being_watched = 0)

	       then (File.write (File.tmp_path (Path.basic "foo_reap_comp"))

	              ("Reaping a watcher, goals watched is: " ^

	                 (string_of_int (!goals_being_watched))^"\n");

	             killWatcher (childpid);  reapWatcher (childpid,childin, childout);()

		     )

	       else () )

	  (* if proof translation failed *)

	 else if ((substring (reconstr, 0,5)) = "Proof")

	 then (goals_being_watched := (!goals_being_watched) -1;

	       Pretty.writeln(Pretty.str ( (concat[(oct_char "360"), (oct_char "377")])));

	       Pretty.writeln(Pretty.str (goalstring^(Recon_Transfer.restore_linebreaks reconstr)));

	       Pretty.writeln(Pretty.str  (oct_char "361"));

	       if (!goals_being_watched = 0)

	       then (File.write (File.tmp_path (Path.basic "foo_reap_comp"))

	              ("Reaping a watcher, goals watched is: " ^

	                 (string_of_int (!goals_being_watched))^"\n");

	             killWatcher (childpid);  reapWatcher (childpid,childin, childout);()

		     )

	       else () )

	 else if ((substring (reconstr, 0,1)) = "%")

	 then (goals_being_watched := (!goals_being_watched) -1;

	       Pretty.writeln(Pretty.str ( (concat[(oct_char "360"), (oct_char "377")])));

	       Pretty.writeln(Pretty.str (goalstring^(Recon_Transfer.restore_linebreaks reconstr)));

	       Pretty.writeln(Pretty.str  (oct_char "361"));

	       if (!goals_being_watched = 0)

	       then (File.write (File.tmp_path (Path.basic "foo_reap_comp"))

	              ("Reaping a watcher, goals watched is: " ^

	                 (string_of_int (!goals_being_watched))^"\n");

	             killWatcher (childpid);  reapWatcher (childpid,childin, childout);()

		     )

	       else () )

	 else  (* add something here ?*)

	      (goals_being_watched := (!goals_being_watched) -1;

	       Pretty.writeln(Pretty.str ( (concat[(oct_char "360"), (oct_char "377")])));

		Pretty.writeln(Pretty.str ("Ran out of options in handler"));

		Pretty.writeln(Pretty.str  (oct_char "361"));

		if (!goals_being_watched = 0)

	        then (File.write (File.tmp_path (Path.basic "foo_reap_comp"))

	              ("Reaping a watcher, goals watched is: " ^

	                 (string_of_int (!goals_being_watched))^"\n");

	             killWatcher (childpid);  reapWatcher (childpid,childin, childout);()

		     )

	        else () )

       end)

 in IsaSignal.signal (IsaSignal.usr1, IsaSignal.SIG_HANDLE vampire_proofHandler);

    IsaSignal.signal (IsaSignal.usr2, IsaSignal.SIG_HANDLE spass_proofHandler);

    (childin, childout, childpid)

  end

end (* structure Watcher *)