X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Focaml%2Fcic_notation%2FcicNotationPres.ml;h=7c87dedce0168ecc76d7d954d782d592fe48b6e4;hb=f981a524748846acc29b76b6e616af110b4ee13d;hp=b898f6d1fe238f2eb33618923d0486f901993b2e;hpb=3d63cb9ed38f05c679fc3284a5b3bb4d92e52296;p=helm.git diff --git a/helm/ocaml/cic_notation/cicNotationPres.ml b/helm/ocaml/cic_notation/cicNotationPres.ml index b898f6d1f..7c87dedce 100644 --- a/helm/ocaml/cic_notation/cicNotationPres.ml +++ b/helm/ocaml/cic_notation/cicNotationPres.ml @@ -23,25 +23,16 @@ * http://helm.cs.unibo.it/ *) +module P = Mpresentation + type mathml_markup = boxml_markup Mpresentation.mpres and boxml_markup = mathml_markup Box.box type markup = mathml_markup let atop_attributes = [None, "linethickness", "0pt"] -let binder_attributes = [None, "mathcolor", "blue"] -let indent_attributes = [None, "indent", "1em"] - -let mpres_arrow = Mpresentation.Mo (binder_attributes, "->") - (* TODO unicode symbol "to" *) -let mpres_implicit = Mpresentation.Mtext ([], "?") -let to_unicode s = - try - if s.[0] = '\\' then - Utf8Macro.expand (String.sub s 1 (String.length s - 1)) - else s - with Utf8Macro.Macro_not_found _ -> s +let to_unicode = Utf8Macro.unicode_of_tex let rec make_attributes l1 = function | [] -> [] @@ -60,46 +51,79 @@ let mpres_of_box = Box.Object (_, mpres) -> mpres | box -> Mpresentation.Mobject ([], box) -let genuine_math = +let rec genuine_math = function - | Mpresentation.Mobject _ -> false + | Mpresentation.Mobject ([], obj) -> not (genuine_box obj) | _ -> true +and genuine_box = + function + | Box.Object ([], mpres) -> not (genuine_math mpres) + | _ -> true + +let rec eligible_math = + function + | Mpresentation.Mobject ([], Box.Object ([], mpres)) -> eligible_math mpres + | Mpresentation.Mobject ([], _) -> false + | _ -> true + +let rec promote_to_math = + function + | Mpresentation.Mobject ([], Box.Object ([], mpres)) -> promote_to_math mpres + | math -> math + +let small_skip = + Mpresentation.Mspace (RenderingAttrs.small_skip_attributes `MathML) let box_of mathonly spec attrs children = match children with - | [t] -> t - | _ -> - let kind, spacing, indent = spec in - let rec dress = function - | [] -> [] - | [hd] -> [hd] - | hd :: tl -> hd :: Mpresentation.Mtext ([], " ") :: dress tl - in - if mathonly then Mpresentation.Mrow (attrs, dress children) - else - let attrs' = - if spacing then [None, "spacing", "0.5em"] else [] - @ if indent then [None, "indent", "0em 0.5em"] else [] - @ attrs - in - match kind with - | CicNotationPt.H when List.for_all genuine_math children -> - Mpresentation.Mrow (attrs', children) - | CicNotationPt.H -> - mpres_of_box (Box.H (attrs', List.map box_of_mpres children)) - | CicNotationPt.V -> - mpres_of_box (Box.V (attrs', List.map box_of_mpres children)) - | CicNotationPt.HV -> - mpres_of_box (Box.HV (attrs', List.map box_of_mpres children)) - | CicNotationPt.HOV -> - mpres_of_box (Box.HOV (attrs', List.map box_of_mpres children)) + | [t] -> t + | _ -> + let kind, spacing, indent = spec in + let dress children = + if spacing then + CicNotationUtil.dress small_skip children + else + children + in + if mathonly then Mpresentation.Mrow (attrs, dress children) + else + let attrs' = + (if spacing then RenderingAttrs.spacing_attributes `BoxML else []) + @ (if indent then RenderingAttrs.indent_attributes `BoxML else []) + @ attrs + in + match kind with + | CicNotationPt.H -> + if List.for_all eligible_math children then + Mpresentation.Mrow (attrs', + dress (List.map promote_to_math children)) + else + mpres_of_box (Box.H (attrs', + List.map box_of_mpres children)) +(* | CicNotationPt.H when List.for_all genuine_math children -> + Mpresentation.Mrow (attrs', dress children) *) + | CicNotationPt.V -> + mpres_of_box (Box.V (attrs', + List.map box_of_mpres children)) + | CicNotationPt.HV -> + mpres_of_box (Box.HV (attrs', + List.map box_of_mpres children)) + | CicNotationPt.HOV -> + mpres_of_box (Box.HOV (attrs', + List.map box_of_mpres children)) -let open_paren = Mpresentation.Mo ([], "(") -let closed_paren = Mpresentation.Mo ([], ")") -let open_box_paren = Box.Text ([], "(") -let closed_box_paren = Box.Text ([], ")") +let open_paren = Mpresentation.Mo ([], "(") +let closed_paren = Mpresentation.Mo ([], ")") +let open_brace = Mpresentation.Mo ([], "{") +let closed_brace = Mpresentation.Mo ([], "}") +let hidden_substs = Mpresentation.Mtext ([], "{...}") +let open_box_paren = Box.Text ([], "(") +let closed_box_paren = Box.Text ([], ")") +let semicolon = Mpresentation.Mo ([], ";") +let toggle_action children = + Mpresentation.Maction ([None, "actiontype", "toggle"], children) -type child_pos = [ `Left | `Right | `Inner ] +type child_pos = [ `None | `Left | `Right | `Inner ] let pp_assoc = function @@ -109,12 +133,12 @@ let pp_assoc = let pp_pos = function - | `Left -> "`Left" - | `Right -> "`Right" - | `Inner -> "`Inner" + `None -> "`None" + | `Left -> "`Left" + | `Right -> "`Right" + | `Inner -> "`Inner" let is_atomic t = - let module P = Mpresentation in let rec aux_mpres = function | P.Mi _ | P.Mo _ @@ -141,8 +165,6 @@ let is_atomic t = aux_mpres t let add_parens child_prec child_assoc child_pos curr_prec t = - prerr_endline (Printf.sprintf "add_parens %d %s %s %d" child_prec - (pp_assoc child_assoc) (pp_pos child_pos) (curr_prec)); if is_atomic t then t else if child_prec < curr_prec || (child_prec = curr_prec && @@ -159,7 +181,7 @@ let add_parens child_prec child_assoc child_pos curr_prec t = else t -let render ids_to_uris t = +let render ids_to_uris = let module A = CicNotationPt in let module P = Mpresentation in let use_unicode = true in @@ -167,113 +189,206 @@ let render ids_to_uris t = | None -> None | Some id -> (try Some (Hashtbl.find ids_to_uris id) with Not_found -> None) in - let make_href xref = - let uri = lookup_uri xref in - make_attributes [Some "helm","xref"; Some "xlink","href"] [xref;uri] + let make_href xmlattrs xref uris = + let xref_uri = lookup_uri xref in + let raw_uris = List.map UriManager.string_of_uri uris in + let uri = + match xref_uri, raw_uris with + | None, [] -> None + | Some uri, [] -> Some uri + | None, raw_uris -> Some (String.concat " " raw_uris) + | Some uri, raw_uris -> Some (String.concat " " (uri :: raw_uris)) + in + xmlattrs + @ make_attributes [Some "helm", "xref"; Some "xlink", "href"] [xref; uri] in let make_xref xref = make_attributes [Some "helm","xref"] [xref] in - let make_box = function - | P.Mobject (attrs, box) -> - assert (attrs = []); - box - | m -> Box.Object ([], m) - in - let make_hv xref children = - let attrs = indent_attributes @ make_href xref in - P.Mobject ([], Box.HV (indent_attributes, List.map make_box children)) - in - let rec invoke mathonly xref prec assoc t = - fst (aux mathonly xref prec assoc t) (* when mathonly is true no boxes should be generated, only mrows *) - and aux mathonly xref prec assoc t = - let return t = t, (prec, assoc) in + let rec aux xmlattrs mathonly xref pos prec uris t = match t with - | A.AttributedTerm (`Loc _, t) -> return (invoke mathonly xref prec assoc t) - | A.AttributedTerm (`Level (prec, assoc), t) -> - return (invoke mathonly xref prec assoc t) - | A.AttributedTerm (`IdRef xref, t) -> - return (invoke mathonly (Some xref) prec assoc t) - - | A.Ident (literal, _) -> return (P.Mi (make_href xref, to_unicode literal)) - | A.Num (literal, _) -> return (P.Mn (make_href xref, to_unicode literal)) - | A.Symbol (literal, _) -> return (P.Mo (make_href xref,to_unicode literal)) - | A.Uri (literal, _) -> return (P.Mi (make_href xref, to_unicode literal)) - - (* default pretty printing shant' be implemented here *) -(* | A.Appl terms -> - let children = aux_children mathonly xref prec assoc terms in - make_hv xref children - | A.Binder (`Pi, (A.Ident ("_", None), ty_opt), body) - | A.Binder (`Forall, (A.Ident ("_", None), ty_opt), body) -> - let ty' = - match ty_opt with - | None -> mpres_implicit - | Some ty -> invoke mathonly None prec assoc ty + | A.AttributedTerm _ -> + aux_attributes xmlattrs mathonly xref pos prec uris t + | A.Num (literal, _) -> + let attrs = + (RenderingAttrs.number_attributes `MathML) + @ make_href xmlattrs xref uris in - let body' = invoke mathonly None prec assoc body in - return (make_hv xref [ty'; make_h None [mpres_arrow; body']]) *) - - | A.Literal l -> aux_literal xref prec assoc l - | A.Layout l -> aux_layout mathonly xref prec assoc l + P.Mn (attrs, literal) + | A.Symbol (literal, _) -> + let attrs = + (RenderingAttrs.symbol_attributes `MathML) + @ make_href xmlattrs xref uris + in + P.Mo (attrs, to_unicode literal) + | A.Ident (literal, subst) + | A.Uri (literal, subst) -> + let attrs = + (RenderingAttrs.ident_attributes `MathML) + @ make_href xmlattrs xref [] + in + let name = P.Mi (attrs, to_unicode literal) in + (match subst with + | Some [] + | None -> name + | Some substs -> + let substs' = + box_of mathonly (A.H, false, false) [] + (open_brace + :: (CicNotationUtil.dress semicolon + (List.map + (fun (name, t) -> + box_of mathonly (A.H, false, false) [] [ + P.Mi ([], name); + P.Mo ([], to_unicode "\\def"); + aux [] mathonly xref pos prec uris t ]) + substs)) + @ [ closed_brace ]) +(* (CicNotationUtil.dress semicolon + (List.map + (fun (var, t) -> + let var_uri = UriManager.uri_of_string var in + let var_name = UriManager.name_of_uri var_uri in + let href_attr = Some "xlink", "href", var in + box_of mathonly (A.H, false, false) [] [ + P.Mi ([href_attr], var_name); + P.Mo ([], to_unicode "\\def"); + aux [] mathonly xref pos prec uris t ]) + substs)) *) + in + let substs_maction = toggle_action [ hidden_substs; substs' ] in + box_of mathonly (A.H, false, false) [] [ name; substs_maction ]) + | A.Literal l -> aux_literal xmlattrs xref prec uris l + | A.UserInput -> P.Mtext ([], "%") + | A.Layout l -> aux_layout mathonly xref pos prec uris l | A.Magic _ | A.Variable _ -> assert false (* should have been instantiated *) - | t -> - prerr_endline (CicNotationPp.pp_term t); + prerr_endline ("unexpected ast: " ^ CicNotationPp.pp_term t); assert false - - and aux_literal xref prec assoc l = - let return t = t, (prec, assoc) in - let attrs = make_href xref in - match l with - | `Symbol s - | `Keyword s -> return (P.Mo (attrs, to_unicode s)) - | `Number s -> return (P.Mn (attrs, to_unicode s)) - and aux_layout mathonly xref prec assoc l = - let return t = t, (prec, assoc) in + and aux_attributes xmlattrs mathonly xref pos prec uris t = + let new_level = ref None in + let new_xref = ref None in + let new_uris = ref [] in + let new_xmlattrs = ref [] in + let rec aux_attribute = + function + | A.AttributedTerm (attr, t) -> + (match attr with + | `Loc _ + | `Raw _ -> () + | `Level (child_prec, child_assoc) -> + new_level := Some (child_prec, child_assoc) + | `IdRef xref -> new_xref := Some xref + | `Href hrefs -> new_uris := hrefs + | `XmlAttrs attrs -> new_xmlattrs := attrs); + aux_attribute t + | t -> + (match !new_level with + | None -> aux !new_xmlattrs mathonly !new_xref pos prec !new_uris t + | Some (child_prec, child_assoc) -> + let t' = + aux !new_xmlattrs mathonly !new_xref pos child_prec !new_uris t + in + add_parens child_prec child_assoc pos prec t') + in + aux_attribute t +(* function + | `Loc _ + | `Raw _ -> aux xmlattrs mathonly xref pos prec uris t + | `Level (child_prec, child_assoc) -> + let t' = aux xmlattrs mathonly xref pos child_prec uris t in + add_parens child_prec child_assoc pos prec t' + | `IdRef xref -> aux xmlattrs mathonly (Some xref) pos prec uris t + | `Href uris' -> aux xmlattrs mathonly xref pos prec uris' t + | `XmlAttrs xmlattrs -> aux xmlattrs mathonly xref pos prec uris t *) + and aux_literal xmlattrs xref prec uris l = + let attrs = make_href xmlattrs xref uris in + (match l with + | `Symbol s -> P.Mo (attrs, to_unicode s) + | `Keyword s -> P.Mo (attrs, to_unicode s) + | `Number s -> P.Mn (attrs, to_unicode s)) + and aux_layout mathonly xref pos prec uris l = let attrs = make_xref xref in - let invoke' t = invoke true None prec assoc t in + let invoke' t = aux [] true None pos prec uris t in match l with - | A.Sub (t1, t2) -> return (P.Msub (attrs, invoke' t1, invoke' t2)) - | A.Sup (t1, t2) -> return (P.Msup (attrs, invoke' t1, invoke' t2)) - | A.Below (t1, t2) -> return (P.Munder (attrs, invoke' t1, invoke' t2)) - | A.Above (t1, t2) -> return (P.Mover (attrs, invoke' t1, invoke' t2)) + | A.Sub (t1, t2) -> P.Msub (attrs, invoke' t1, invoke' t2) + | A.Sup (t1, t2) -> P.Msup (attrs, invoke' t1, invoke' t2) + | A.Below (t1, t2) -> P.Munder (attrs, invoke' t1, invoke' t2) + | A.Above (t1, t2) -> P.Mover (attrs, invoke' t1, invoke' t2) | A.Frac (t1, t2) - | A.Over (t1, t2) -> return (P.Mfrac (attrs, invoke' t1, invoke' t2)) + | A.Over (t1, t2) -> P.Mfrac (attrs, invoke' t1, invoke' t2) | A.Atop (t1, t2) -> - return (P.Mfrac (atop_attributes @ attrs, invoke' t1, invoke' t2)) - | A.Sqrt t -> return (P.Msqrt (attrs, invoke' t)) - | A.Root (t1, t2) -> return (P.Mroot (attrs, invoke' t1, invoke' t2)) - | A.Box (kind, terms) -> - let children = aux_children mathonly xref prec assoc terms in - return (box_of mathonly kind attrs children) - and aux_children mathonly xref prec assoc terms = - let rec aux_list first = + P.Mfrac (atop_attributes @ attrs, invoke' t1, invoke' t2) + | A.Sqrt t -> P.Msqrt (attrs, invoke' t) + | A.Root (t1, t2) -> P.Mroot (attrs, invoke' t1, invoke' t2) + | A.Box ((_, spacing, _) as kind, terms) -> + let children = + aux_children mathonly spacing xref pos prec uris + (CicNotationUtil.ungroup terms) + in + box_of mathonly kind attrs children + | A.Group terms -> + let children = + aux_children mathonly false xref pos prec uris + (CicNotationUtil.ungroup terms) + in + box_of mathonly (A.H, false, false) attrs children + | A.Break -> assert false (* TODO? *) + and aux_children mathonly spacing xref pos prec uris terms = + let find_clusters = + let rec aux_list first clusters acc = + function + [] when acc = [] -> List.rev clusters + | [] -> aux_list first (List.rev acc :: clusters) [] [] + | (A.Layout A.Break) :: tl when acc = [] -> + aux_list first clusters [] tl + | (A.Layout A.Break) :: tl -> + aux_list first (List.rev acc :: clusters) [] tl + | [hd] -> + let pos' = + if first then + pos + else + match pos with + `None -> `Right + | `Inner -> `Inner + | `Right -> `Right + | `Left -> `Inner + in + aux_list false clusters + (aux [] mathonly xref pos' prec uris hd :: acc) [] + | hd :: tl -> + let pos' = + match pos, first with + `None, true -> `Left + | `None, false -> `Inner + | `Left, true -> `Left + | `Left, false -> `Inner + | `Right, _ -> `Inner + | `Inner, _ -> `Inner + in + aux_list false clusters + (aux [] mathonly xref pos' prec uris hd :: acc) tl + in + aux_list true [] [] + in + let boxify_pres = function - [] -> [] - | [t] -> - let t', (child_prec, child_assoc) = aux mathonly xref prec assoc t in - prerr_endline ("T " ^ CicNotationPp.pp_term t); - [add_parens child_prec child_assoc `Right prec t'] - | t :: tl -> - let t', (child_prec, child_assoc) = aux mathonly xref prec assoc t in - prerr_endline ( "T " ^ CicNotationPp.pp_term t); - let child_pos = if first then `Left else `Inner in - let hd = add_parens child_prec child_assoc child_pos prec t' in - hd :: aux_list false tl + [t] -> t + | tl -> box_of mathonly (A.H, spacing, false) [] tl in - match terms with - [t] -> [invoke mathonly xref prec assoc t] - | tl -> aux_list true tl + List.map boxify_pres (find_clusters terms) in - fst (aux false None 0 Gramext.NonA t) + aux [] false None `None 0 [] -let render_to_boxml id_to_uri t = - let rec print_box (t: CicNotationPres.boxml_markup) = - Box.box2xml print_mpres t - and print_mpres (t: CicNotationPres.mathml_markup) = - Mpresentation.print_mpres print_box t - in +let rec print_box (t: CicNotationPres.boxml_markup) = + Box.box2xml print_mpres t +and print_mpres (t: CicNotationPres.mathml_markup) = + Mpresentation.print_mpres print_box t + +let print_xml = print_mpres + +(* let render_to_boxml id_to_uri t = let xml_stream = print_box (box_of_mpres (render id_to_uri t)) in - Ast2pres.add_xml_declaration xml_stream + Xml.add_xml_declaration xml_stream *)