(* convert sml-datatypes to xml

   authors: Walther Neuper 2003

   (c) due to copyright terms

use"xmlsrc/datatypes.sml";

use"datatypes.sml";

*)

signature DATATYPES =

  sig

    val authors2xml : int -> string -> string list -> xml

    val calc2xml : int -> thyID * calc -> xml

    val calcrefs2xml : int -> thyID * calc list -> xml

    val contthy2xml : int -> contthy -> xml

    val extref2xml : int -> string -> string -> xml

    val filterpbl :

       ''a -> (''a * (Term.term * Term.term)) list -> Term.term list

    val formula2xml : int -> Term.term -> xml

    val formulae2xml : int -> Term.term list -> xml

    val i : int

    val id2xml : int -> string list -> string

    val ints2xml : int -> int list -> string

    val itm_2xml : int -> SpecifyTools.itm_ -> xml

    val itms2xml :

       int ->

       (int * SpecifyTools.vats * bool * string * SpecifyTools.itm_) list ->

       string

    val keref2xml : int -> ketype -> kestoreID -> xml

    val model2xml :

       int -> SpecifyTools.itm list -> (bool * Term.term) list -> xml

    val modspec2xml : int -> ocalhd -> xml

    val pattern2xml :

       int ->

       (string * (Term.term * Term.term)) list -> Term.term list -> string

    val pos'2xml : int -> string * (int list * pos_) -> string

    val pos'calchead2xml : int -> pos' * ocalhd -> xml

    val pos_2xml : int -> pos_ -> string

    val posform2xml : int -> pos' * Term.term -> xml

    val posformhead2xml : int -> pos' * ptform -> string

    val posformheads2xml : int -> (pos' * ptform) list -> xml

    val posforms2xml : int -> (pos' * Term.term) list -> xml

    val posterms2xml : int -> (pos' * term) list -> xml

    val precond2xml : int -> bool * Term.term -> xml

    val preconds2xml : int -> (bool * Term.term) list -> xml

    val rls2xml : int -> thyID * rls -> xml

    val rule2xml : int -> guh -> rule -> xml

    val rules2xml : int -> guh -> rule list -> xml

    val scr2xml : int -> scr -> xml

    val spec2xml : int -> spec -> xml

    val sub2xml : int -> Term.term * Term.term -> xml

    val subs2xml : int -> subs -> xml

    val subst2xml : int -> subst -> xml

    val tac2xml : int -> tac -> xml

    val tacs2xml : int -> tac list -> xml

    val theref2xml : int -> thyID -> string -> xstring -> string

    val thm'2xml : int -> thm' -> xml

    val thm''2xml : int -> thm -> xml

    val thmstr2xml : int -> string -> xml

  end

(*------------------------------------------------------------------

structure datatypes:DATATYPES =

(*structure datatypes =*)

struct

------------------------------------------------------------------*)

(** general types: lists,  **)

fun xml_of_bool b = XML.Elem (("BOOL", []), [XML.Text (bool2str b)])

fun xml_to_bool (XML.Elem (("BOOL", []), [XML.Text b])) = string_to_bool b

  | xml_to_bool tree = error ("xml_to_bool: wrong XML.tree \n" ^ xmlstr 0 tree)

fun xml_to_ketype (XML.Elem (("KETYPE", []), [XML.Text str])) = str2ketype str

  | xml_to_ketype tree = error ("xml_to_ketype: wrong XML.tree \n" ^ xmlstr 0 tree)

(*.handles string list like 'fun id2xml'.*)

fun authors2xml j str auts = 

    let fun autx _ [] = ""

	  | autx j (s::ss) = (indt j) ^ "<STRING> " ^ s ^ " </STRING>\n" ^ 

			     (autx j ss)

    in indt j ^ "<"^str^">\n" ^

       autx (j + i) auts ^ 

       indt j ^ "</"^str^">\n" : xml

    end;

(* writeln(authors2xml 2 "MATHAUTHORS" []);

   writeln(authors2xml 2 "MATHAUTHORS" 

		       ["isac-team 2001", "Richard Lang 2003"]);

   *)

fun id2xml j ids =

    let fun id2x _ [] = ""

	  | id2x j (s::ss) = (indt j) ^ "<STRING> " ^ s ^ " </STRING>\n" ^ 

			     (id2x j ss)

    in (indt j) ^ "<STRINGLIST>\n" ^ 

       (id2x (j + indentation) ids) ^ 

       (indt j) ^ "</STRINGLIST>\n" end;

(* writeln(id2xml 8 ["linear","univariate","equation"]);

        <STRINGLIST>

          <STRING>linear</STRING>

          <STRING>univariate</STRING>

          <STRING>equation</STRING>

        </STRINGLIST>*)

fun xml_of_str str = XML.Elem (("STRING", []), [XML.Text str])

fun xml_of_strs strs = XML.Elem (("STRINGLIST", []), map xml_of_str strs)

fun xml_to_str (XML.Elem (("STRING", []), [XML.Text str])) = str

  | xml_to_str tree = error ("xml_to_str: wrong XML.tree \n" ^ xmlstr 0 tree)

fun xml_to_strs (XML.Elem (("STRINGLIST", []), strs)) = map xml_to_str strs

  | xml_to_strs tree = error ("xml_to_strs: wrong XML.tree \n" ^ xmlstr 0 tree)

fun ints2xml j ids =

    let fun int2x _ [] = ""

	  | int2x j (s::ss) = (indt j) ^"<INT> "^ string_of_int s ^" </INT>\n"^

			     (int2x j ss)

    in (indt j) ^ "<INTLIST>\n" ^ 

       (int2x (j + i) ids) ^ 

       (indt j) ^ "</INTLIST>\n" end;

(* writeln(ints2xml 3 [1,2,3]);

   *)

fun xml_of_int i = XML.Elem (("INT", []), [XML.Text (string_of_int i)])

fun xml_of_ints is = (*xml/datatypes.sml: fun ints2xml*)

  XML.Elem (("INTLIST", []), map xml_of_int is)

fun xml_to_int (XML.Elem (("INT", []), [XML.Text i])) = 

      (case int_of_str i of SOME i => i | _ => error "xml_to_int: int_of_str \<Rightarrow> NONE")

  | xml_to_int tree = error ("xml_to_int: wrong XML.tree \n" ^ xmlstr 0 tree)

fun xml_to_ints (XML.Elem (("INTLIST", []), is)) = map xml_to_int is

  | xml_to_ints tree = error ("xml_to_ints: wrong XML.tree \n" ^ xmlstr 0 tree)

(** isac datatypes **)

fun pos_2xml j pos_ =

    (indt j) ^ "<POS> " ^  pos_2str pos_ ^ " </POS>\n";

(*.due to specialties of isac/util/parser/XMLParseDigest.java

   pos' requires different tags.*)

fun pos'2xml j (tag, (pos, pos_)) =

    indt     (j) ^ "<" ^ tag ^ ">\n" ^ 

    ints2xml (j+i) pos ^ 

    pos_2xml (j+i) pos_ ^ 

    indt     (j) ^ "</" ^ tag ^ ">\n";

(* writeln(pos'2xml 3 ("POSITION", ([1,2,3], Pbl)));

   *)

fun xml_of_pos tag (is, pp) = (*xml/datatypes.sml: fun pos'2xml*)

  XML.Elem ((tag, []), [

    xml_of_ints is,

    XML.Elem (("POS", []), [XML.Text (pos_2str pp)])])

fun xml_to_pos_ (XML.Elem (("POS", []), [XML.Text pp])) = str2pos_ pp

  | xml_to_pos_ tree = error ("xml_to_pos_: wrong XML.tree \n" ^ xmlstr 0 tree)

fun xml_to_pos (XML.Elem (("POSITION", []), [is, pp])) = (xml_to_ints is, xml_to_pos_ pp) (*: pos'*)

  | xml_to_pos tree = error ("xml_to_pos: wrong XML.tree \n" ^ xmlstr 0 tree)

fun xml_of_auto (Step i) = 

      XML.Elem (("AUTO", []), [XML.Text "Step", XML.Text (string_of_int i)])

  | xml_of_auto CompleteModel = XML.Elem (("AUTO", []), [XML.Text "CompleteModel"])

  | xml_of_auto CompleteCalcHead = XML.Elem (("AUTO", []), [XML.Text "CompleteCalcHead"])

  | xml_of_auto CompleteToSubpbl = XML.Elem (("AUTO", []), [XML.Text "CompleteToSubpbl"])

  | xml_of_auto CompleteSubpbl = XML.Elem (("AUTO", []), [XML.Text "CompleteSubpbl"])

  | xml_of_auto CompleteCalc = XML.Elem (("AUTO", []), [XML.Text "CompleteCalc"])

fun xml_to_auto (XML.Elem (("AUTO", []), [XML.Text "Step", XML.Text i])) = Step (int_of_str i |>the)

  | xml_to_auto (XML.Elem (("AUTO", []), [XML.Text "CompleteModel"])) = CompleteModel

  | xml_to_auto (XML.Elem (("AUTO", []), [XML.Text "CompleteCalcHead"])) = CompleteCalcHead

  | xml_to_auto (XML.Elem (("AUTO", []), [XML.Text "CompleteToSubpbl"])) = CompleteToSubpbl

  | xml_to_auto (XML.Elem (("AUTO", []), [XML.Text "CompleteSubpbl"])) = CompleteSubpbl

  | xml_to_auto (XML.Elem (("AUTO", []), [XML.Text "CompleteCalc"])) = CompleteCalc

  | xml_to_auto tree = error ("xml_to_auto: wrong XML.tree \n" ^ xmlstr 0 tree)

fun formula2xml j term = (*TODO.WN050211: use for _all_ <FORMULA>*)

    indt j ^ "<FORMULA>\n"^

    term2xml j term ^"\n"^

    indt j ^ "</FORMULA>\n" : xml;

fun xml_of_formula term = 

  XML.Elem (("FORMULA", []), [xml_of_term term])

fun xml_to_formula 

      (XML.Elem (("FORMULA", []), [form])) = xml_to_term form

  | xml_to_formula x = raise ERROR ("xml_to_formula wrong arg: " ^ xmlstr 0 x)

(* TODO test/Tools/isac/xmlsrc/datatypes.sml*)

fun formulae2xml j [] = ("":xml)

  | formulae2xml j (r::rs) = formula2xml j r ^ formulae2xml j rs;

(* writeln(formulae2xml 6 [str2term "1+1=2", str2term "1+1+1=3"]);

   *)

(*WN0502 @see ME/ctree: type asms: illdesigned, thus not used*)

fun posform2xml j (p:pos', term) =

    indt j ^     "<POSFORM>\n" ^

    pos'2xml (j+i) ("POSITION", p) ^

    indt     (j+i) ^ "<FORMULA>\n"^

    term2xml (j+i) term ^"\n"^

    indt     (j+i) ^ "</FORMULA>\n"^

    indt j ^     "</POSFORM>\n" : xml;

(* writeln(posform2xml 6 (([1,2],Frm), str2term "1+1=2"));

   *)

fun posforms2xml j [] = ("":xml)

  | posforms2xml j (r::rs) = posform2xml j r ^ posforms2xml j rs;

(* writeln(posforms2xml 6 [(([1],Res), str2term "1+1=2"),(([2],Res), str2term "1+1+1=3")]);

   *)

fun calcref2xml j (thyID:thyID, (scrop, (rewop, _)):calc) =

    indt j ^ "<CALCREF>\n" ^

    indt (j+i) ^ "<STRING> " ^ scrop ^ "</STRING>\n" ^

    indt (j+i) ^ "<GUH> " ^ cal2guh ("IsacKnowledge", 

				      thyID) scrop  ^ " </GUH>\n" ^

    indt j ^ "</CALCREF>\n" : xml;

fun calcrefs2xml _ (_,[]) = "":xml

  | calcrefs2xml j (thyID, cal::cs) = 

    calcref2xml j (thyID, cal) ^ calcrefs2xml j (thyID, cs);

fun calc2xml j (thyID:thyID, (scrop, (rewop, _)):calc) =

    indt j ^ "<CALC>\n" ^

    indt (j+i) ^ "<STRING>\n" ^ scrop ^ "</STRING>\n" ^

    indt (j+i) ^ "<GUH>\n" ^ cal2guh ("IsacKnowledge", 

				      thyID) scrop  ^ "</GUH>\n" ^

    indt (j+i) ^ "<TERMOP>\n" ^ rewop ^ "</TERMOP>\n" ^

    indt j ^ "</CALC>\n" : xml;

(*.for creating a href for a rule within an rls's rule list;

   the guh points to the thy of definition of the rule, NOT of use in rls.*)

fun rule2xml j (thyID:thyID) Erule =

      error "rule2xml called with 'Erule'"

  | rule2xml j thyID (Thm (thmDeriv, thm)) =

      indt j ^ "<RULE>\n" ^

      indt (j+i) ^ "<TAG> Theorem </TAG>\n" ^

      indt (j+i) ^ "<STRING> " ^ thmID_of_derivation_name thmDeriv ^ " </STRING>\n" ^

      indt (j+i) ^ "<GUH> " ^ 

        thm2guh (thy_containing_thm thmDeriv) (thmID_of_derivation_name thmDeriv) ^ " </GUH>\n" ^

        indt j ^ "</RULE>\n" : xml

  | rule2xml j thyID (Calc (termop, _)) = ""

(*FIXXXXXXXME.WN060714 in rls make Calc : calc -> rule [add scriptop!]

  see smltest/../datatypes.sml !

    indt j ^ "<RULE>\n" ^

    indt (j+i) ^ "<STRING> " ^ termop ^ " </STRING>\n" ^

    indt (j+i) ^ "<GUH> " ^ cal2guh (thy_containing_cal thyID termop) 

				    termop ^ " </GUH>\n" ^

    indt j ^ "</RULE>\n"

*)

  | rule2xml j thyID (Cal1 (termop, _)) = ""

  | rule2xml j thyID (Rls_ rls) =

      let val rls' = (#id o rep_rls) rls

      in

        indt j ^ "<RULE>\n" ^

        indt (j+i) ^ "<TAG> Ruleset </TAG>\n" ^

        indt (j+i) ^ "<STRING> " ^ rls' ^ " </STRING>\n" ^

        indt (j+i) ^ "<GUH> " ^ rls2guh (thy_containing_rls thyID rls') rls' ^ " </GUH>\n" ^

        indt j ^ "</RULE>\n"

      end;

fun rules2xml j thyID [] = ("":xml)

  | rules2xml j thyID (r::rs) = rule2xml j thyID r ^ rules2xml j thyID rs;

fun filterpbl str =

  let fun filt [] = []

        | filt ((s, (t1, t2)) :: ps) = 

	  if str = s then (t1 $ t2) :: filt ps else filt ps

  in filt end;

(*FIXME.WN040831 model2xml <--?--> pattern2xml*)

(*WN.25.8.03: pattern2xml different output with TextIO | writeln !!!

  the version below is for TextIO: terms2xml makes \n !*)

(* val (j, p, where_) = (i, ppc, where_);

   *)

fun pattern2xml j p where_ =

    (case filterpbl "#Given" p of

	[] =>  (indt j) ^ "<GIVEN>  </GIVEN>\n"

(* val gis = filterpbl "#Given" p;

   *)

      | gis => (indt j) ^ "<GIVEN>\n" ^ terms2xml' j gis ^

	       (indt j) ^ "</GIVEN>\n")

    ^ 

    (case where_ of

	 [] =>  (indt j) ^ "<WHERE>  </WHERE>\n"

       | whs => (indt j) ^ "<WHERE>\n" ^ terms2xml' j whs ^

		(indt j) ^ "</WHERE>\n")

    ^ 

    (case filterpbl "#Find" p of

	 [] =>  (indt j) ^ "<FIND>  </FIND>\n"

       | fis => (indt j) ^ "<FIND>\n" ^ terms2xml' j fis ^

		(indt j) ^ "</FIND>\n")

    ^ 

    (case filterpbl "#Relate" p of

	 [] =>  (indt j) ^ "<RELATE>  </RELATE>\n"

       | res => (indt j) ^ "<RELATE>\n" ^ terms2xml' j res ^

		(indt j) ^ "</RELATE>\n");

(*

writeln(pattern2xml 3 ((#ppc o get_pbt)

			 ["squareroot","univariate","equation","test"]) []);

  *)

(*see itm_2item*)

fun itm_2xml j (Cor (dts,_)) =

    (indt j ^"<ITEM status=\"correct\">\n"^    

    term2xml (j) (comp_dts' dts)^"\n"^    

    indt j ^"</ITEM>\n"):xml

  | itm_2xml j (Syn c) =

    indt j ^"<ITEM status=\"syntaxerror\">\n"^    

    indt (j) ^c^    

    indt j ^"</ITEM>\n"

  | itm_2xml j (Typ c) =

    indt j ^"<ITEM status=\"typeerror\">\n"^    

    indt (j) ^c^    

    indt j ^"</ITEM>\n"

  (*type item also has 'False of cterm' set in preconds2xml WN 050618*)

  | itm_2xml j (Inc (dts,_)) = 

    indt j ^"<ITEM status=\"incomplete\">\n"^    

    term2xml (j) (comp_dts' dts)^"\n"^    

    indt j ^"</ITEM>\n"

  | itm_2xml j (Sup dts) = 

    indt j ^"<ITEM status=\"superfluous\">\n"^    

    term2xml (j) (comp_dts' dts)^"\n"^    

    indt j ^"</ITEM>\n"

  | itm_2xml j (Mis (d,pid)) =

    indt j ^"<ITEM status=\"missing\">\n"^    

    term2xml (j) (d $ pid)^"\n"^    

    indt j ^"</ITEM>\n";

fun xml_of_itm_ (Cor (dts, _)) =

    XML.Elem (("ITEM", [("status", "correct")]), [xml_of_term (comp_dts' dts)])

  | xml_of_itm_ (Syn c) =

    XML.Elem (("ITEM", [("status", "syntaxerror")]), [XML.Text c])

  | xml_of_itm_ (Typ c) =

    XML.Elem (("ITEM", [("status", "typeerror")]), [XML.Text c])

  (*type item also has 'False of cterm' set in preconds2xml WN 050618*)

  | xml_of_itm_ (Inc (dts, _)) = 

    XML.Elem (("ITEM", [("status", "incomplete")]), [xml_of_term (comp_dts' dts)])

  | xml_of_itm_ (Sup dts) = 

    XML.Elem (("ITEM", [("status", "superfluous")]), [xml_of_term (comp_dts' dts)])

  | xml_of_itm_ (Mis (d, pid)) = 

    XML.Elem (("ITEM", [("status", "missing")]), [xml_of_term (d $ pid)])

(*see terms2xml' fpr \n*)

fun itms2xml _ [] = ""

  | itms2xml j [(_,_,_,_,itm_)] = itm_2xml j itm_

  | itms2xml j (((_,_,_,_,itm_):itm)::itms) =

    itm_2xml j itm_ ^ itms2xml j itms;

fun xml_of_itms itms =

  let 

    fun extract (_, _, _, _, itm_) = itm_

      | extract _ = error "xml_of_itms.extract: wrong argument" 

  in map (xml_of_itm_ o extract) itms end

fun precond2xml j (true, term) =

    (indt j ^"<ITEM status=\"correct\">\n"^

    term2xml (j) term^"\n"^

    indt j ^"</ITEM>\n"):xml

  | precond2xml j (false, term) =

    indt j ^"<ITEM status=\"false\">\n"^

    term2xml (j+i) term^"\n"^

    indt j ^"</ITEM>\n";

fun xml_of_precond (status, term) =

    XML.Elem (("ITEM", [("status", if status then "correct" else "false")]), [xml_of_term term])

fun preconds2xml _ [] = ("":xml)

  | preconds2xml j (p::ps) = precond2xml j p ^ preconds2xml j ps;

fun xml_of_preconds ps = map xml_of_precond ps

(*FIXME.WN040831 model2xml <--?--> pattern2xml*)

fun model2xml j (itms:itm list) where_ =

  let fun eq4 str (_,_,_,field,_) = str = field

  in  (indt j ^"<MODEL>\n"^

    (case filter (eq4 "#Given") itms of

         [] =>  (indt (j+i)) ^ "<GIVEN>  </GIVEN>\n"

       | gis => (indt (j+i)) ^ "<GIVEN>\n" ^ itms2xml (j+2*i) gis ^

          (indt (j+i)) ^ "</GIVEN>\n")

    ^

    (case where_ of

         [] =>  (indt (j+i)) ^ "<WHERE>  </WHERE>\n"

       | whs => (indt (j+i)) ^ "<WHERE>\n" ^ preconds2xml (j+2*i) whs ^

          (indt (j+i)) ^ "</WHERE>\n")

    ^

    (case filter (eq4 "#Find") itms of

         [] =>  (indt (j+i)) ^ "<FIND>  </FIND>\n"

       | fis => (indt (j+i)) ^ "<FIND>\n" ^ itms2xml (j+2*i) fis ^

          (indt (j+i)) ^ "</FIND>\n")

    ^

    (case filter (eq4 "#Relate") itms of

         [] =>  (indt (j+i)) ^ "<RELATE>  </RELATE>\n"

       | res => (indt (j+i)) ^ "<RELATE>\n" ^ itms2xml (j+2*i) res ^

          (indt (j+i)) ^ "</RELATE>\n")^

        indt j ^"</MODEL>\n"):xml

  end;

(* writeln(model2xml 3 itms []);

   *)

fun xml_of_model itms where_ =

  let

    fun eq str (_, _, _,field, _) = str = field

  in 

    XML.Elem (("MODEL", []), [

      XML.Elem (("GIVEN", []), 

        filter (eq "#Given") itms |> xml_of_itms),

      XML.Elem (("WHERE", []), 

        xml_of_preconds where_),

      XML.Elem (("FIND", []), 

        filter (eq "#Find") itms |> xml_of_itms),

      XML.Elem (("RELATE", []), 

        filter (eq "#Relate") itms |> xml_of_itms)])

  end 

fun spec2xml j ((dI,pI,mI):spec) =

    (indt j ^"<SPECIFICATION>\n"^

    indt (j+i) ^"<THEORYID> "^ dI ^" </THEORYID>\n"^

    indt (j+i) ^"<PROBLEMID>\n"^

    id2xml (j+2*i) pI ^

    indt (j+i) ^"</PROBLEMID>\n"^

    indt (j+i) ^"<METHODID>\n"^

    id2xml (j+2*i) mI ^

    indt (j+i) ^"</METHODID>\n"^

    indt j ^"</SPECIFICATION>\n"):xml;

fun xml_of_spec (thyID, pblID, metID) =

  XML.Elem (("SPECIFICATION", []), [

    XML.Elem (("THEORYID", []), [XML.Text thyID]),

    XML.Elem (("PROBLEMID", []), [xml_of_strs pblID]),

    XML.Elem (("METHODID", []), [xml_of_strs metID])])

fun xml_to_spec (XML.Elem (("SPECIFICATION", []), [

      XML.Elem (("THEORYID", []), [XML.Text thyID]),

      XML.Elem (("PROBLEMID", []), [ps]),

      XML.Elem (("METHODID", []), [ms])])) = (thyID, xml_to_strs ps, xml_to_strs ms)

  | xml_to_spec tree = error ("xml_to_spec: wrong XML.tree \n" ^ xmlstr 0 tree)

fun xml_of_variant (items, spec) = 

  XML.Elem (("VARIANT", []), [xml_of_strs items, xml_of_spec spec])

fun xml_to_variant (XML.Elem (("VARIANT", []), [items, spec])) = 

    (xml_to_strs items, xml_to_spec spec)

  | xml_to_variant tree = error ("xml_to_variant: wrong XML.tree \n" ^ xmlstr 0 tree)

fun xml_of_fmz [] = xml_of_fmz [e_fmz]

  | xml_of_fmz vs = XML.Elem (("FORMALIZATION", []), map xml_of_variant vs)

fun xml_to_fmz (XML.Elem (("FORMALIZATION", []), vars)) = map xml_to_variant vars

  | xml_to_fmz tree = error ("xml_to_fmz: wrong XML.tree \n" ^ xmlstr 0 tree)

fun modspec2xml j ((b, p_, head, gfr, pre, spec): ocalhd) =

    (indt j ^"<CALCHEAD status = "^

     quote (if b then "correct" else "incorrect")^">\n"^

     indt (j+i) ^"<HEAD>\n"^

     term2xml (j+i) head^"\n"^

     indt (j+i) ^"</HEAD>\n"^

     model2xml (j+i) gfr pre ^

     indt (j+i) ^"<BELONGSTO> "^(case p_ of Pbl => "Pbl"

					  | Met => "Met"

					  | _ => "Und")^" </BELONGSTO>\n"^

     spec2xml (j+i) spec ^

     indt j ^"</CALCHEAD>\n"):xml;

fun xml_of_modspec ((b, p_, head, gfr, pre, spec): ocalhd) =

  XML.Elem (("CALCHEAD", [("status", if b then "correct" else "incorrect")]), [

    XML.Elem (("HEAD", []), [xml_of_term head]),

    xml_of_model gfr pre,

    XML.Elem (("BELONGSTO", []), [

      XML.Text (case p_ of Pbl => "Pbl" | Met => "Met" | _ => "Und")]),

    xml_of_spec spec])

fun pos'calchead2xml j (p:pos', (b, p_, head, gfr, pre, spec): ocalhd) =

    (indt j ^"<CALCHEAD status = "^

     quote (if b then "correct" else "incorrect")^">\n"^

     pos'2xml (j+i) ("POSITION", p) ^

     indt (j+i) ^"<HEAD>\n"^

     term2xml (j+i) head^"\n"^

     indt (j+i) ^"</HEAD>\n"^

     model2xml (j+i) gfr pre ^

     indt (j+i) ^"<BELONGSTO> "^(case p_ of Pbl => "Pbl"

					  | Met => "Met"

					  | _ => "Und")^" </BELONGSTO>\n"^

     spec2xml (j+i) spec ^

     indt j ^"</CALCHEAD>\n"):xml;

fun xml_of_posmodspec ((p: pos', (b, p_, head, gfr, pre, spec): ocalhd)) =

  XML.Elem (("CALCHEAD", [("status", if b then "correct" else "incorrect")]), [

    xml_of_pos "POSITION" p,

    XML.Elem (("HEAD", []), [xml_of_term head]),

    xml_of_model gfr pre,

    XML.Elem (("BELONGSTO", []), [

      XML.Text (case p_ of Pbl => "Pbl" | Met => "Met" | _ => "Und")]),

    xml_of_spec spec])

fun xml_to_imodel

    (XML.Elem (("IMODEL", []), [

      XML.Elem (("GIVEN", []), givens),

      (*XML.Elem (("WHERE", []), wheres),  ... Where is never input*)

      XML.Elem (("FIND", []), finds),

      XML.Elem (("RELATE", []), relates)])) =

    ([Given (map xml_to_cterm givens), 

      Find (map xml_to_cterm finds), 

      Relate (map xml_to_cterm relates)]): imodel

  | xml_to_imodel x = raise ERROR ("xml_to_imodel: WRONG arg = " ^ xmlstr 0 x)

fun xml_to_icalhd

    (XML.Elem (("ICALCHEAD", []), [

      pos as XML.Elem (("POSITION", []), _),

      headln as XML.Elem (("MATHML", []), _),

      imodel as XML.Elem (("MATHML", []), _), (* TODO WN150813 ?!?*)

      XML.Elem (("POS", []), [XML.Text belongsto]),

      spec as XML.Elem (("SPECIFICATION", []), _)])) =

    (xml_to_pos pos, xml_to_cterm headln, xml_to_imodel imodel, 

    str2pos_ belongsto, xml_to_spec spec): icalhd

  | xml_to_icalhd x = raise ERROR ("xml_to_icalhd: WRONG arg = " ^ xmlstr 0 x)

fun sub2xml j (id, value) =

    (indt j ^"<PAIR>\n"^

     indt j ^"  <VARIABLE>\n"^

     term2xml (j+i) id ^ "\n" ^

     indt j ^"  </VARIABLE>\n" ^

     indt j ^"  <VALUE>\n"^

     term2xml (j+i) value ^ "\n" ^

     indt j ^"  </VALUE>\n" ^

     indt j ^"</PAIR>\n"):xml;

fun xml_of_sub (id, value) =

  XML.Elem (("PAIR", []), [

    XML.Elem (("VARIABLE", []), [xml_of_term id]),

    XML.Elem (("VALUE", []), [xml_of_term value])])

fun xml_to_sub

    (XML.Elem (("PAIR", []), [

      XML.Elem (("VARIABLE", []), [id]),

      XML.Elem (("VALUE", []), [value])])) = (xml_to_term id, xml_to_term value)

  | xml_to_sub x = raise ERROR ("xml_to_sub wrong arg: " ^ xmlstr 0 x)

fun subs2xml j (subs:subs) =

    (indt j ^"<SUBSTITUTION>\n"^

     foldl op^ ("", map (sub2xml (j+i))

			(subs2subst (assoc_thy "Isac") subs)) ^

     indt j ^"</SUBSTITUTION>\n"):xml;

fun xml_of_subs (subs : subs) =

  XML.Elem (("SUBSTITUTION", []), map xml_of_sub (subs2subst (assoc_thy "Isac") subs))

fun xml_to_subs

    (XML.Elem (("SUBSTITUTION", []), 

      subs)) = (subst2subs (map xml_to_sub subs) : subs)

  | xml_to_subs x = raise ERROR ("xml_to_subs wrong arg: " ^ xmlstr 0 x)

fun xml_of_sube (sube : sube) =

  XML.Elem (("SUBSTITUTION", []), map xml_of_sub (sube2subst (assoc_thy "Isac") sube))

fun xml_to_sube

    (XML.Elem (("SUBSTITUTION", []), 

      xml_var_val_pairs)) = subst2sube (map xml_to_sub xml_var_val_pairs)

  | xml_to_sube x = raise ERROR ("xml_to_sube wrong arg: " ^ xmlstr 0 x)

fun subst2xml j (subst:subst) =

    (indt j ^"<SUBSTITUTION>\n"^

     foldl op^ ("", map (sub2xml (j+i)) subst) ^

     indt j ^"</SUBSTITUTION>\n"):xml;

(* val subst = [(str2term "bdv", str2term "x")];

   writeln(subst2xml 0 subst);

   *)

(* val (j, str) = ((j+i), form);

   *)

fun thmstr2xml j str = ((((term2xml j) o str2term) str)^"\n"):xml;

(* val (j, ((ID, form):thm')) = ((j+i), thm');

   *)

fun thm'2xml j ((ID, form):thm') =

    (indt j ^"<THEOREM>\n"^

    indt (j+i) ^"<ID> "^ID^" </ID>\n"^

    indt (j+i) ^"<FORMULA>\n"^

    thmstr2xml (j+i) form^

    indt (j+i) ^"</FORMULA>\n"^

    indt j ^"</THEOREM>\n"):xml;

fun xml_of_thm' ((ID, form) : thm') =

  XML.Elem (("THEOREM", []), [

    XML.Elem (("ID", []), [XML.Text ID]),

    XML.Elem (("FORMULA", []), [

      XML.Text form])])           (* repair for MathML: use term instead String *)

fun xml_to_thm'

    (XML.Elem (("THEOREM", []), [

      XML.Elem (("ID", []), [XML.Text ID]),

      XML.Elem (("FORMULA", []), [(* repair for MathML: use term instead String *)

        XML.Text form])])) = ((ID, form) : thm')

  | xml_to_thm' x = raise ERROR ("xml_of_thm' wrong arg:" ^ xmlstr 0 x)

(*WN060627 scope of thy's not considered ?!?*)

fun thm''2xml j (thm : thm) =

    indt j ^ "<THEOREM>\n" ^

    indt (j+i) ^ "<ID> " ^ thmID_of_derivation_name' thm ^ " </ID>\n"^

    term2xml j (prop_of thm) ^ "\n" ^

    indt j ^ "</THEOREM>\n" : xml;

fun xml_of_thm (thm : thm) =

  XML.Elem (("THEOREM", []), [

    XML.Elem (("ID", []), [XML.Text (thmID_of_derivation_name' thm)]),

    xml_of_term (prop_of thm)])

fun scr2xml j EmptyScr =

    indt j ^"<SCRIPT>  </SCRIPT>\n" : xml

  | scr2xml j (Prog term) =

    if term = e_term 

    then indt j ^"<SCRIPT>  </SCRIPT>\n"

    else indt j ^"<SCRIPT>\n"^ 

	 term2xml j (inst_abs (assoc_thy "Isac") term) ^ "\n" ^

	 indt j ^"</SCRIPT>\n"

  | scr2xml j (Rfuns _) =

    indt j ^"<REVERSREWRITE> reverse rewrite functions </REVERSREWRITE>\n";

fun xml_of_src EmptyScr =

    XML.Elem (("SCRIPT", []), [XML.Text "empty_script"])

  | xml_of_src (Prog term) =

    XML.Elem (("SCRIPT", []), [

      if term = e_term then xml_of_src EmptyScr 

      else XML.Elem (("SCRIPT", []), [xml_of_term (inst_abs (assoc_thy "Isac") term)])])

  | xml_of_src (Rfuns _) =

    XML.Elem (("REVERSREWRITE", []), [XML.Text "reverse rewrite functions"])

fun prepa12xml j (terms, term) =

    indt j ^"<PREPAT>\n"^

    indt (j+i) ^"<PRECONDS>\n"^

    terms2xml (j+2*i) terms ^

    indt (j+i) ^"</PRECONDS>\n"^

    indt (j+i) ^"<PATTERN>\n"^

    term2xml (j+2*i) term ^

    indt (j+i) ^"</PATTERN>\n"^

    indt j ^"</PREPAT>\n" : xml;

fun prepat2xml j [] = ""

  | prepat2xml j (p::ps) = prepa12xml j p ^ prepat2xml j ps : xml;

(* val (j, (thyID, seqrls, {id, preconds, rew_ord=(ord,_), erls,

			    srls, calc, rules, scr})) = 

	   (j, (thyID, "Seq", data));

   *)

fun rls2xm j (thyID, seqrls, {id, preconds, rew_ord=(ord,_), erls,

		      srls, calc, rules, errpatts, scr}) =

    indt j ^"<RULESET>\n"^

    indt (j+i) ^"<ID> "^ id ^" </ID>\n"^

    indt (j+i) ^"<TYPE> "^ seqrls ^" </TYPE>\n"^

    indt (j+i) ^"<RULES>\n" ^

    rules2xml (j+2*i) thyID rules ^

    indt (j+i) ^"</RULES>\n" ^

    indt (j+i) ^"<PRECONDS> " ^

    terms2xml' (j+2*i) preconds ^

    indt (j+i) ^"</PRECONDS>\n" ^

    indt (j+i) ^"<ORDER>\n" ^

    indt (j+2*i) ^ "<STRING> " ^ ord ^ " </STRING>\n" ^

(*WN060714 thy_isac_*-ord-*.xml not yet generated ................

    indt (j+2*i) ^ "<GUH> " ^ ord2guh ("IsacKnowledge", 

				      thyID) ord ^ " </GUH>\n" ^

..................................................................*)

    indt (j+i) ^"</ORDER>\n" ^

    indt (j+i) ^"<ERLS>\n" ^

    indt (j+2*i) ^ "<TAG> Ruleset </TAG>\n" ^

    indt (j+2*i) ^ "<STRING> " ^ id_rls erls ^ " </STRING>\n" ^

    indt (j+2*i) ^ "<GUH> " ^ rls2guh ("IsacKnowledge", thyID) 

				     (id_rls erls) ^ " </GUH>\n" ^

    indt (j+i) ^"</ERLS>\n" ^

    indt (j+i) ^"<SRLS>\n" ^

    indt (j+2*i) ^ "<TAG> Ruleset </TAG>\n" ^

    indt (j+2*i) ^ "<STRING> " ^ id_rls erls ^ " </STRING>\n" ^

    indt (j+2*i) ^ "<GUH> " ^ rls2guh ("IsacKnowledge", thyID) 

				     (id_rls srls) ^ " </GUH>\n" ^

    indt (j+i) ^"</SRLS>\n" ^

    calcrefs2xml (j+i) (thyID, calc) ^

    scr2xml (j+i) scr ^

    indt j ^"</RULESET>\n" : xml;

fun rls2xml j (thyID, Erls) = rls2xml j (thyID, e_rls)

  | rls2xml j (thyID, Rls data) = rls2xm j (thyID, "Rls", data)

  | rls2xml j (thyID, Seq data) = rls2xm j (thyID, "Seq", data)

  | rls2xml j (thyID, Rrls {id, prepat, rew_ord=(ord,_), erls, calc, errpatts, scr}) = 

    indt j ^"<RULESET>\n"^

    indt (j+i) ^"<ID> "^ id ^" </ID>\n"^

    indt (j+i) ^"<TYPE> Rrls </TYPE>\n"^

    prepat2xml (j+i) prepat ^

    indt (j+i) ^"<ORDER> " ^

    indt (j+2*i) ^ "<TAG> Rewrite order </TAG>\n" ^

    indt (j+2*i) ^ "<STRING> " ^ ord ^ " </STRING>\n" ^

(*WN060714 thy_isac_*-ord-*.xml not yet generated ................

    indt (j+2*i) ^ "<GUH> " ^ ord2guh ("IsacKnowledge", 

				      thyID) ord ^ " </GUH>\n" ^

.................................................................*)

    indt (j+i) ^"</ORDER>\n" ^

    indt (j+i) ^"<ERLS> " ^

    indt (j+2*i) ^ "<TAG> Ruleset </TAG>\n" ^

    indt (j+2*i) ^ "<STRING> " ^ id_rls erls ^ " </STRING>\n" ^

    indt (j+2*i) ^ "<GUH> " ^ rls2guh ("IsacKnowledge", thyID) (id_rls erls) ^ " </GUH>\n" ^

    indt (j+i) ^"</ERLS>\n" ^

    calcrefs2xml (j+i) (thyID, calc) ^

    indt (j+i) ^"<SCRIPT>\n"^ 

    scr2xml (j+2*i) scr ^

    indt (j+i) ^" </SCRIPT>\n"^

    indt j ^"</RULESET>\n" : xml;

(*.convert a tactic into xml-format

   ATTENTION: WN060513 detected faulty 'cterm2xml's with 'string's as args.*)

fun tac2xml j (Subproblem (dI, pI)) =

    (indt j ^"<SUBPROBLEMTACTIC name=\"Subproblem\">\n"^

    indt (j+i) ^"<THEORY> "^ dI ^" </THEORY>\n"^

    indt (j+i) ^"<PROBLEM>\n"^

    id2xml (j+2*i) pI^

    indt (j+i) ^"</PROBLEM>\n"^

    indt j ^"</SUBPROBLEMTACTIC>\n"):xml

  | tac2xml j Model_Problem =

    (indt j ^"<STRINGLISTTACTIC name=\"Model_Problem\">"^

    indt j ^"</STRINGLISTTACTIC>\n"):xml

  | tac2xml j (Refine_Tacitly pI) =

    (indt j ^"<STRINGLISTTACTIC name=\"Refine_Tacitly\">\n"^

    id2xml (j+i) pI^

    indt j ^"</STRINGLISTTACTIC>\n"):xml

  | tac2xml j (Add_Given ct) =

    (indt j ^"<SIMPLETACTIC name=\"Add_Given\">\n"^

    cterm2xml (j+i) ct^

    indt j ^"</SIMPLETACTIC>\n"):xml

  | tac2xml j (Add_Find ct) =

    (indt j ^"<SIMPLETACTIC name=\"Add_Find\">\n"^

    cterm2xml (j+i) ct^

    indt j ^"</SIMPLETACTIC>\n"):xml

  | tac2xml j (Add_Relation ct) =

    (indt j ^"<SIMPLETACTIC name=\"Add_Relation\">\n"^

    cterm2xml (j+i) ct^

    indt j ^"</SIMPLETACTIC>\n"):xml

  | tac2xml j (Specify_Theory ct) =

    (indt j ^"<SIMPLETACTIC name=\"Specify_Theory\">\n"^

    cterm2xml (j+i) ct^(*WN060513 Specify_Theory = fn : domID -> tac

and domID is a string, not a cterm *)

    indt j ^"</SIMPLETACTIC>\n"):xml

  | tac2xml j (Specify_Problem ct) =

    (indt j ^"<STRINGLISTTACTIC name=\"Specify_Problem\">\n"^

    id2xml (j+i) ct^

    indt j ^"</STRINGLISTTACTIC>\n"):xml

  | tac2xml j (Specify_Method ct) =

    (indt j ^"<STRINGLISTTACTIC name=\"Specify_Method\">\n"^

    id2xml (j+i) ct^

    indt j ^"</STRINGLISTTACTIC>\n"):xml

  | tac2xml j (Apply_Method mI) =

    (indt j ^"<STRINGLISTTACTIC name=\"Apply_Method\">\n"^

    id2xml (j+i) mI^

    indt j ^"</STRINGLISTTACTIC>\n"):xml

  | tac2xml j (Take ct) =

    (indt j ^"<SIMPLETACTIC name=\"Take\">\n"^

    cterm2xml (j+i) ct^

    indt j ^"</SIMPLETACTIC>\n"):xml

  | tac2xml j (Calculate opstr) =

    (indt j ^"<SIMPLETACTIC name=\"Calculate\">\n"^

    cterm2xml (j+i) opstr^(*WN060513 Calculate = fn : string -> tac

			'string', _NOT_ 'cterm' ..flaw from RG*)

    indt j ^"</SIMPLETACTIC>\n"):xml

(* val (j, Rewrite thm') = (i, tac);

   *)

  | tac2xml j (Rewrite thm') =

    (indt j ^"<REWRITETACTIC name=\"Rewrite\">\n"^

    thm'2xml (j+i) thm'^

    indt j ^"</REWRITETACTIC>\n"):xml

(* writeln (tac2xml 2 (Rewrite ("all_left",

				"~ ?b =!= 0 ==> (?a = ?b) = (?a - ?b = 0)")));

   val (j, (Rewrite_Inst (subs, thm'))) = (i, tac);

   *)

  | tac2xml j (Rewrite_Inst (subs, thm')) =

    (indt j ^"<REWRITEINSTTACTIC name=\"Rewrite_Inst\">\n"^

    subs2xml (j+i) subs^

    thm'2xml (j+i) thm'^

    indt j ^"</REWRITEINSTTACTIC>\n"):xml

(* writeln (tac2xml 2 (Rewrite_Inst

			   (["(bdv,x)"],

			    ("all_left",

			     "~ ?b =!= 0 ==> (?a = ?b) = (?a - ?b = 0)"))));

   *)

  | tac2xml j (Rewrite_Set rls') =

    (indt j ^"<REWRITESETTACTIC name=\"Rewrite_Set\">\n"^

    indt (j+i) ^"<RULESET> "^ rls' ^" </RULESET>\n"^

    indt j ^"</REWRITESETTACTIC>\n"):xml

  | tac2xml j (Rewrite_Set_Inst (subs, rls')) =

    (indt j ^"<REWRITESETINSTTACTIC name=\"Rewrite_Set_Inst\">\n"^

    indt (j+i) ^"<RULESET> "^ rls' ^" </RULESET>\n"^

    subs2xml (j+i) subs^

    indt j ^"</REWRITESETINSTTACTIC>\n"):xml

  | tac2xml j (Or_to_List) =

    (indt j ^"<STRINGLISTTACTIC name=\"Or_to_List\"> </STRINGLISTTACTIC>\n"):xml

  | tac2xml j (Check_elementwise ct) =

    (indt j ^"<SIMPLETACTIC name=\"Check_elementwise\">\n"^

    cterm2xml (j+i) ct ^ "\n"^

    indt j ^"</SIMPLETACTIC>\n"):xml

  (*WN0605 quick and dirty: cterms is _NOT_ a stringlist like pblID...*)

  | tac2xml j (Substitute cterms) =

    (indt j ^"<STRINGLISTTACTIC name=\"Substitute\">\n"^

    (*cterms2xml (j+i) cterms^  ....should be WN060514: TODO TERMLISTTACTIC?*)

    id2xml (j+i) cterms^

    indt j ^"</STRINGLISTTACTIC>\n"):xml

  | tac2xml j (Check_Postcond pI) =

    (indt j ^"<STRINGLISTTACTIC name=\"Check_Postcond\">\n"^

    id2xml (j+i) pI^

    indt j ^"</STRINGLISTTACTIC>\n"):xml

  | tac2xml j tac = error ("tac2xml: not impl. for "^tac2str tac);

fun xml_of_tac (Subproblem (dI, pI)) =

    XML.Elem (("SUBPROBLEMTACTIC", [("name", "Subproblem")]), [

      XML.Elem (("THEORY", []), [XML.Text dI]),

      XML.Elem (("PROBLEM", []), [xml_of_strs pI])])

  | xml_of_tac (Substitute cterms) =

    (*Substitute: sube -> tac; e_sube: cterm' list; UNCLEAR HOW TO INPUT ON FRONTEND*)

    XML.Elem (("STRINGLISTTACTIC", [("name", "Substitute")]), [xml_of_sube cterms])

    (*----- Rewrite* -----------------------------------------------------*)

  | xml_of_tac (Rewrite thm') =

    XML.Elem (("REWRITETACTIC", [("name", "Rewrite")]), [xml_of_thm' thm'])

  | xml_of_tac (Rewrite_Inst (subs, thm')) =

    XML.Elem (("REWRITEINSTTACTIC", [("name", "Rewrite_Inst")]), (

      xml_of_subs subs ::

      xml_of_thm' thm' :: []))

  | xml_of_tac (Rewrite_Set rls') =

    XML.Elem (("REWRITESETTACTIC", [("name", "Rewrite_Set")]), [XML.Text rls'])

  | xml_of_tac (Rewrite_Set_Inst (subs, rls')) =

    XML.Elem (("REWRITESETINSTTACTIC", [("name", "Rewrite_Set_Inst")]), ([

      xml_of_subs subs,

      XML.Elem (("RULESET", []), [XML.Text rls'])]))

    (*----- FORMTACTIC ---------------------------------------------------*)

  | xml_of_tac (Add_Find ct) =

    XML.Elem (("FORMTACTIC", [("name", "Add_Find")]), [xml_of_cterm ct])

  | xml_of_tac (Add_Given ct) =

    XML.Elem (("FORMTACTIC", [("name", "Add_Given")]), [xml_of_cterm ct])

  | xml_of_tac (Add_Relation ct) =

    XML.Elem (("FORMTACTIC", [("name", "Add_Relation")]), [xml_of_cterm ct])

  | xml_of_tac (Check_elementwise ct) =

    XML.Elem (("FORMTACTIC", [("name", "Check_elementwise")]), [xml_of_cterm ct])

  | xml_of_tac (Take ct) =

    XML.Elem (("FORMTACTIC", [("name", "Take")]), [xml_of_cterm ct])

    (*----- SIMPLETACTIC -------------------------------------------------*)

  | xml_of_tac (Calculate opstr) =

    XML.Elem (("SIMPLETACTIC", [("name", "Calculate")]), [XML.Text opstr])

  | xml_of_tac (Or_to_List) =

    XML.Elem (("SIMPLETACTIC", [("name", "Or_to_List")]), [(*//////////*)])

  | xml_of_tac (Specify_Theory ct) =

    XML.Elem (("SIMPLETACTIC", [("name", "Specify_Theory")]), [XML.Text ct])

    (*----- STRINGLISTTACTIC ---------------------------------------------*)

  | xml_of_tac (Apply_Method mI) =

    XML.Elem (("STRINGLISTTACTIC", [("name", "Apply_Method")]), [xml_of_strs mI])

  | xml_of_tac (Check_Postcond pI) =

    XML.Elem (("STRINGLISTTACTIC", [("name", "Check_Postcond")]), [xml_of_strs pI])

  | xml_of_tac Model_Problem =

    XML.Elem (("STRINGLISTTACTIC", [("name", "Model_Problem")]), [])

  | xml_of_tac (Refine_Tacitly pI) =

    XML.Elem (("STRINGLISTTACTIC", [("name", "Refine_Tacitly")]), [xml_of_strs pI])

  | xml_of_tac (Specify_Method ct) =

    XML.Elem (("STRINGLISTTACTIC", [("name", "Specify_Method")]), [xml_of_strs ct])

  | xml_of_tac (Specify_Problem ct) =

    XML.Elem (("STRINGLISTTACTIC", [("name", "Specify_Problem")]), [xml_of_strs ct])

  | xml_of_tac tac = error ("xml_of_tac: not impl. for " ^ tac2str tac);

fun xml_to_tac 

    (XML.Elem (("SUBPROBLEMTACTIC", [("name", "Subproblem")]), [

      XML.Elem (("THEORY", []), [XML.Text dI]),

      XML.Elem (("PROBLEM", []), [pI])])) = Subproblem (dI, xml_to_strs pI)

  | xml_to_tac

    (*Substitute: sube -> tac; e_sube: cterm' list; UNCLEAR HOW TO INPUT ON FRONTEND*)

    (XML.Elem (("STRINGLISTTACTIC", [

      ("name", "Substitute")]), [cterms])) = Substitute (xml_to_sube cterms)

    (*----- Rewrite* -----------------------------------------------------*)

  | xml_to_tac

    (XML.Elem (("REWRITETACTIC", [

      ("name", "Rewrite")]), [thm'])) = Rewrite (xml_to_thm' thm')

  | xml_to_tac

    (XML.Elem (("REWRITEINSTTACTIC", [

      ("name", "Rewrite_Inst")]), [

        subs, thm'])) = Rewrite_Inst (xml_to_subs subs, xml_to_thm' thm')

  | xml_to_tac

    (XML.Elem (("REWRITESETTACTIC", [

      ("name", "Rewrite_Set")]), [XML.Text rls'])) = Rewrite_Set (rls')

  | xml_to_tac

    (XML.Elem (("REWRITESETINSTTACTIC", [

      ("name", "Rewrite_Set_Inst")]), [

        subs,

        XML.Elem (("RULESET", []), [XML.Text rls'])])) = Rewrite_Set_Inst (xml_to_subs subs, rls')

    (*----- FORMTACTIC ---------------------------------------------------*)

  | xml_to_tac

    (XML.Elem (("FORMTACTIC", [

      ("name", "Add_Find")]), [ct])) =  Add_Find (xml_to_cterm ct)

  | xml_to_tac

    (XML.Elem (("FORMTACTIC", [

      ("name", "Add_Given")]), [ct])) = Add_Given (xml_to_cterm ct)

  | xml_to_tac

    (XML.Elem (("FORMTACTIC", [

      ("name", "Add_Relation")]), [ct])) = Add_Relation (xml_to_cterm ct)

  | xml_to_tac

    (XML.Elem (("FORMTACTIC", [

      ("name", "Take")]), [ct])) = Take (xml_to_cterm ct)

  | xml_to_tac

    (XML.Elem (("FORMTACTIC", [

      ("name", "Check_elementwise")]), [ct])) = Check_elementwise (xml_to_cterm ct)

    (*----- SIMPLETACTIC -------------------------------------------------*)

  | xml_to_tac

    (XML.Elem (("SIMPLETACTIC", [

      ("name", "Calculate")]), [XML.Text opstr])) = Calculate opstr

  | xml_to_tac

    (XML.Elem (("SIMPLETACTIC", [("name", "Or_to_List")]), [])) = Or_to_List

  | xml_to_tac

    (XML.Elem (("SIMPLETACTIC", [

      ("name", "Specify_Theory")]), [XML.Text ct])) = Specify_Theory ct

    (*----- STRINGLISTTACTIC ---------------------------------------------*)

  | xml_to_tac

    (XML.Elem (("STRINGLISTTACTIC", [

      ("name", "Apply_Method")]), [mI])) = Apply_Method (xml_to_strs  mI)

  | xml_to_tac

    (XML.Elem (("STRINGLISTTACTIC", [

      ("name", "Check_Postcond")]), [pI])) = Check_Postcond (xml_to_strs pI)

  | xml_to_tac

    (XML.Elem (("STRINGLISTTACTIC", [

      ("name", "Model_Problem")]), [])) = Model_Problem 

  | xml_to_tac

    (XML.Elem (("STRINGLISTTACTIC", [

      ("name", "Refine_Tacitly")]), [pI])) = Refine_Tacitly (xml_to_strs pI)

  | xml_to_tac

    (XML.Elem (("STRINGLISTTACTIC", [

      ("name", "Specify_Method")]), [ct])) = Specify_Method (xml_to_strs ct)

  | xml_to_tac

    (XML.Elem (("STRINGLISTTACTIC", [

      ("name", "Specify_Problem")]), [ct])) = Specify_Problem (xml_to_strs ct)

  | xml_to_tac x = raise ERROR ("xml_to_tac: not impl. for " ^ xmlstr 0 x);

fun tacs2xml j [] = "":xml

  | tacs2xml j (t::ts) = tac2xml j t ^ tacs2xml j ts;

fun posformhead2xml j (p:pos', Form f) =

    indt j ^"<CALCFORMULA>\n"^

    pos'2xml (j+i) ("POSITION", p) ^

    indt (j+i) ^"<FORMULA>\n"^

    term2xml (j+i) f^"\n"^

    indt (j+i) ^"</FORMULA>\n"^

    indt j ^"</CALCFORMULA>\n"

  | posformhead2xml j (p, ModSpec c) =

    pos'calchead2xml (j) (p, c);

fun posformheads2xml j [] = ("":xml)

  | posformheads2xml j (r::rs) = posformhead2xml j r ^ posformheads2xml j rs;

val e_pblterm = (term_of o the o (parse @{theory Script})) 

		    ("Problem (" ^ e_domID ^ "," ^ strs2str' e_pblID ^ ")");

(*WN051224 minimal adaption to exporting Formulae _only_ by getFormulaeFromTo*)

fun posterm2xml j (p:pos', t) =

    indt j ^"<CALCFORMULA>\n"^

    pos'2xml (j+i) ("POSITION", p) ^

    indt (j+i) ^"<FORMULA>\n"^

    (if t = e_pblterm (*headline in pbl is e_ <- _root_pbl for CAS-command*)

     then cterm2xml (j+i) "________________________________________________" 

     else term2xml (j+i) t)^"\n" ^

    indt (j+i) ^"</FORMULA>\n"^

    indt j ^"</CALCFORMULA>\n";

fun xml_of_posterm ((p : pos'), t) = 

  XML.Elem (("CALCFORMULA", []),

    [xml_of_pos "POSITION" p,

    XML.Elem (("FORMULA", []), [

      if t = e_pblterm (*headline in pbl is e_ <- _root_pbl for CAS-command*)

      then xml_of_cterm "________________________________________________"

      else xml_of_term t])])

fun posterms2xml j [] = ("":xml)

  | posterms2xml j (r::rs) = posterm2xml j r ^ posterms2xml j rs;

fun  asm_val2xml j (asm, vl) = 

    indt j ^ "<ASMEVALUATED>\n" ^

    indt (j+i) ^ "<ASM>\n" ^

    term2xml (j+i) asm ^ "\n" ^

    indt (j+i) ^ "</ASM>\n" ^

    indt (j+i) ^ "<VALUE>\n" ^

    term2xml (j+i) vl ^ "\n" ^

    indt (j+i) ^ "</VALUE>\n" ^

    indt j ^ "</ASMEVALUATED>\n" : xml;

fun xml_of_asm_val (asm, vl) =

  XML.Elem (("ASMEVALUATED", []),[

    XML.Elem (("ASM", []), [xml_of_term asm]),

    XML.Elem (("VALUE", []), [xml_of_term vl])])

fun asm_vals2xml j [] = ("":xml)

  | asm_vals2xml j (asm_val::avs) = asm_val2xml j asm_val ^

				    asm_vals2xml j avs;

(*.a reference to an element in the theory hierarchy; 

   compare 'fun keref2xml'.*)

(* val (j, thyID, typ, xstring) = 

       (i+i, snd (thy_containing_rls thy' prls'), "Rulesets", prls');

   *)

fun theref2xml j (thyID:thyID) typ (xstring:xstring) =

    let val guh = theID2guh ["IsacKnowledge", thyID, typ, xstring]

	val typ' = (implode o (drop_last_n 1) o Symbol.explode) typ

    in indt j ^ "<KESTOREREF>\n" ^

       indt (j+i) ^ "<TAG> " ^ typ' ^ " </TAG>\n" ^

       indt (j+i) ^ "<ID> " ^ xstring ^ " </ID>\n" ^

       indt (j+i) ^ "<GUH> " ^ guh ^ " </GUH>\n" ^

       indt j ^ "</KESTOREREF>\n" : xml

    end;

fun xml_of_theref (thyid : thyID) typ (xstring : xstring) =

  let 

    val guh = theID2guh ["IsacKnowledge", thyid, typ, xstring]

    val typ' = (implode o (drop_last_n 1) o Symbol.explode) typ

  in 

    XML.Elem (("KESTOREREF", []),[

      XML.Elem (("TAG", []), [XML.Text typ']),

      XML.Elem (("ID", []), [XML.Text xstring]),

      XML.Elem (("GUH", []), [XML.Text guh])])

  end

(*.a reference to an element in the kestore EXCEPT theory hierarchy; 

   compare 'fun theref2xml'.*)

(* val (j, typ, kestoreID) = (i+i, Met_, hd met);

   *)

fun keref2xml j typ (kestoreID:kestoreID) =

    let val id = strs2str' kestoreID

	val guh = kestoreID2guh typ kestoreID

    in indt j ^ "<KESTOREREF>\n" ^

       indt (j+i) ^ "<TAG> " ^ ketype2str' typ ^ "</TAG>\n" ^

       indt (j+i) ^ "<ID> " ^ id ^ " </ID>\n" ^

       indt (j+i) ^ "<GUH> " ^ guh ^ " </GUH>\n" ^

       indt j ^ "</KESTOREREF>\n" : xml