]> matita.cs.unibo.it Git - helm.git/blob - helm/software/components/content_pres/cicNotationPres.ml
more pps
[helm.git] / helm / software / components / content_pres / cicNotationPres.ml
1 (* Copyright (C) 2004-2005, HELM Team.
2  * 
3  * This file is part of HELM, an Hypertextual, Electronic
4  * Library of Mathematics, developed at the Computer Science
5  * Department, University of Bologna, Italy.
6  * 
7  * HELM is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  * 
12  * HELM is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with HELM; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
20  * MA  02111-1307, USA.
21  * 
22  * For details, see the HELM World-Wide-Web page,
23  * http://helm.cs.unibo.it/
24  *)
25
26 (* $Id$ *)
27
28 open Printf
29
30 module Ast = CicNotationPt
31 module Mpres = Mpresentation
32
33 type mathml_markup = boxml_markup Mpres.mpres
34 and boxml_markup = mathml_markup Box.box
35
36 type markup = mathml_markup
37
38 let atop_attributes = [None, "linethickness", "0pt"]
39
40 let to_unicode = Utf8Macro.unicode_of_tex
41
42 let rec make_attributes l1 = function
43   | [] -> []
44   | hd :: tl ->
45       (match hd with
46       | None -> make_attributes (List.tl l1) tl
47       | Some s ->
48           let p,n = List.hd l1 in
49           (p,n,s) :: make_attributes (List.tl l1) tl)
50
51 let box_of_mpres =
52   function
53   | Mpresentation.Mobject (attrs, box) ->
54       assert (attrs = []);
55       box
56   | mpres -> Box.Object ([], mpres)
57
58 let mpres_of_box =
59   function
60   | Box.Object (attrs, mpres) ->
61       assert (attrs = []);
62       mpres
63   | box -> Mpresentation.Mobject ([], box)
64
65 let rec genuine_math =
66   function
67   | Mpresentation.Mobject ([], obj) -> not (genuine_box obj)
68   | _ -> true
69 and genuine_box =
70   function
71   | Box.Object ([], mpres) -> not (genuine_math mpres)
72   | _ -> true
73
74 let rec eligible_math =
75   function
76   | Mpresentation.Mobject ([], Box.Object ([], mpres)) -> eligible_math mpres
77   | Mpresentation.Mobject ([], _) -> false
78   | _ -> true
79
80 let rec promote_to_math =
81   function
82   | Mpresentation.Mobject ([], Box.Object ([], mpres)) -> promote_to_math mpres
83   | math -> math
84
85 let small_skip =
86   Mpresentation.Mspace (RenderingAttrs.small_skip_attributes `MathML)
87
88 let rec add_mpres_attributes new_attr = function
89   | Mpresentation.Mobject (attr, box) ->
90       Mpresentation.Mobject (attr, add_box_attributes new_attr box)
91   | mpres ->
92       Mpresentation.set_attr (new_attr @ Mpresentation.get_attr mpres) mpres
93 and add_box_attributes new_attr = function
94   | Box.Object (attr, mpres) ->
95       Box.Object (attr, add_mpres_attributes new_attr mpres)
96   | box -> Box.set_attr (new_attr @ Box.get_attr box) box
97
98 let box_of mathonly spec attrs children =
99   match children with
100     | [t] -> add_mpres_attributes attrs t
101     | _ ->
102         let kind, spacing, indent = spec in
103         let dress children =
104           if spacing then
105             CicNotationUtil.dress small_skip children
106           else
107             children
108         in
109           if mathonly then Mpresentation.Mrow (attrs, dress children)
110           else
111             let attrs' =
112               (if spacing then RenderingAttrs.spacing_attributes `BoxML else [])
113               @ (if indent then RenderingAttrs.indent_attributes `BoxML else [])
114               @ attrs
115             in
116               match kind with
117                 | Ast.H ->
118                     if List.for_all eligible_math children then
119                       Mpresentation.Mrow (attrs',
120                         dress (List.map promote_to_math children))
121                     else
122                       mpres_of_box (Box.H (attrs',
123                         List.map box_of_mpres children))
124 (*                 | Ast.H when List.for_all genuine_math children ->
125                     Mpresentation.Mrow (attrs', dress children) *)
126                 | Ast.V ->
127                     mpres_of_box (Box.V (attrs',
128                       List.map box_of_mpres children))
129                 | Ast.HV ->
130                     mpres_of_box (Box.HV (attrs',
131                       List.map box_of_mpres children))
132                 | Ast.HOV ->
133                     mpres_of_box (Box.HOV (attrs',
134                       List.map box_of_mpres children))
135
136 let open_paren        = Mpresentation.Mo ([], "(")
137 let closed_paren      = Mpresentation.Mo ([], ")")
138 let open_bracket      = Mpresentation.Mo ([], "[")
139 let closed_bracket    = Mpresentation.Mo ([], "]")
140 let open_brace        = Mpresentation.Mo ([], "{")
141 let closed_brace      = Mpresentation.Mo ([], "}")
142 let hidden_substs     = Mpresentation.Mtext ([], "{...}")
143 let hidden_lctxt      = Mpresentation.Mtext ([], "[...]")
144 let open_box_paren    = Box.Text ([], "(")
145 let closed_box_paren  = Box.Text ([], ")")
146 let semicolon         = Mpresentation.Mo ([], ";")
147 let toggle_action children =
148   Mpresentation.Maction ([None, "actiontype", "toggle"], children)
149
150 type child_pos = [ `Left | `Right | `Inner ]
151
152 let pp_assoc =
153   function
154   | Gramext.LeftA -> "LeftA"
155   | Gramext.RightA -> "RightA"
156   | Gramext.NonA -> "NonA"
157
158 let is_atomic t =
159   let rec aux_mpres = function
160     | Mpres.Mi _
161     | Mpres.Mo _
162     | Mpres.Mn _
163     | Mpres.Ms _
164     | Mpres.Mtext _
165     | Mpres.Mspace _ -> true
166     | Mpres.Mobject (_, box) -> aux_box box
167     | Mpres.Maction (_, [mpres])
168     | Mpres.Mrow (_, [mpres]) -> aux_mpres mpres
169     | _ -> false
170   and aux_box = function
171     | Box.Space _
172     | Box.Ink _
173     | Box.Text _ -> true
174     | Box.Object (_, mpres) -> aux_mpres mpres
175     | Box.H (_, [box])
176     | Box.V (_, [box])
177     | Box.HV (_, [box])
178     | Box.HOV (_, [box])
179     | Box.Action (_, [box]) -> aux_box box
180     | _ -> false
181   in
182   aux_mpres t
183
184 let add_parens child_prec curr_prec t =
185   if is_atomic t then 
186     ((*prerr_endline ("NOT adding parens around ATOMIC: "^
187       BoxPp.render_to_string (function x::_->x|_->assert false)
188         ~map_unicode_to_tex:false 80 t);*)t)
189   else if child_prec >= 0 && child_prec < curr_prec then 
190     begin 
191     (*prerr_endline ("adding parens around: "^
192       BoxPp.render_to_string (function x::_->x|_->assert false)
193         ~map_unicode_to_tex:false 80 t);*)
194     match t with
195     | Mpresentation.Mobject (_, box) ->
196         mpres_of_box (Box.H ([], [ open_box_paren; box; closed_box_paren ]))
197     | mpres -> Mpresentation.Mrow ([], [open_paren; t; closed_paren])
198   end else
199     ((*prerr_endline ("NOT adding parens around: "^
200       BoxPp.render_to_string (function x::_->x|_->assert false)
201         ~map_unicode_to_tex:false 80 t);*)t)
202
203 let render ids_to_uris ?(prec=(-1)) =
204   let module A = Ast in
205   let module P = Mpresentation in
206 (*   let use_unicode = true in *)
207   let lookup_uri id =
208     (try
209       let uri = Hashtbl.find ids_to_uris id in
210       Some (UriManager.string_of_uri uri)
211     with Not_found -> None)
212   in
213   let make_href xmlattrs xref =
214     let xref_uris =
215       List.fold_right
216         (fun xref uris ->
217           match lookup_uri xref with
218           | None -> uris
219           | Some uri -> uri :: uris)
220         !xref []
221     in
222     let xmlattrs_uris, xmlattrs =
223       let xref_attrs, other_attrs =
224         List.partition
225           (function Some "xlink", "href", _ -> true | _ -> false)
226           xmlattrs
227       in
228       List.map (fun (_, _, uri) -> uri) xref_attrs,
229       other_attrs
230     in
231     let uris =
232       match xmlattrs_uris @ xref_uris with
233       | [] -> None
234       | uris ->
235           Some (String.concat " "
236             (HExtlib.list_uniq (List.sort String.compare uris)))
237     in
238     let xrefs =
239       match !xref with [] -> None | xrefs -> Some (String.concat " " xrefs)
240     in
241     xref := [];
242     xmlattrs
243     @ make_attributes [Some "helm", "xref"; Some "xlink", "href"]
244         [xrefs; uris]
245   in
246   let make_xref xref =
247     let xrefs =
248       match !xref with [] -> None | xrefs -> Some (String.concat " " xrefs)
249     in
250     xref := [];
251     make_attributes [Some "helm","xref"] [xrefs]
252   in
253   (* when mathonly is true no boxes should be generated, only mrows *)
254   (* "xref" is  *)
255   let rec aux xmlattrs mathonly xref  prec t =
256     match t with
257     | A.AttributedTerm _ ->
258         aux_attributes xmlattrs mathonly xref  prec t
259     | A.Num (literal, _) ->
260         let attrs =
261           (RenderingAttrs.number_attributes `MathML)
262           @ make_href xmlattrs xref
263         in
264         Mpres.Mn (attrs, literal)
265     | A.Symbol (literal, _) ->
266         let attrs =
267           (RenderingAttrs.symbol_attributes `MathML)
268           @ make_href xmlattrs xref
269         in
270         Mpres.Mo (attrs, to_unicode literal)
271     | A.Ident (literal, subst)
272     | A.Uri (literal, subst) ->
273         let attrs =
274           (RenderingAttrs.ident_attributes `MathML)
275           @ make_href xmlattrs xref
276         in
277         let name = Mpres.Mi (attrs, to_unicode literal) in
278         (match subst with
279         | Some []
280         | None -> name
281         | Some substs ->
282             let substs' =
283               box_of mathonly (A.H, false, false) []
284                 (open_brace
285                 :: (CicNotationUtil.dress semicolon
286                     (List.map
287                       (fun (name, t) ->
288                         box_of mathonly (A.H, false, false) [] [
289                           Mpres.Mi ([], name);
290                           Mpres.Mo ([], to_unicode "\\def");
291                           aux [] mathonly xref  prec t ])
292                       substs))
293                 @ [ closed_brace ])
294             in
295             let substs_maction = toggle_action [ hidden_substs; substs' ] in
296             box_of mathonly (A.H, false, false) [] [ name; substs_maction ])
297     | A.Meta(n, l) ->
298         let local_context l =
299           box_of mathonly (A.H, false, false) []
300             ([ Mpres.Mtext ([], "[") ] @ 
301             (CicNotationUtil.dress (Mpres.Mtext ([],  ";"))
302               (List.map 
303                 (function 
304                 | None -> Mpres.Mtext ([],  "_")
305                 | Some t -> aux xmlattrs mathonly xref  prec t) l)) @
306              [ Mpres.Mtext ([], "]")])
307         in
308         let lctxt_maction = toggle_action [ hidden_lctxt; local_context l ] in
309         box_of mathonly (A.H, false, false) []
310           ([Mpres.Mtext ([], "?"^string_of_int n) ] 
311             @ (if l <> [] then [lctxt_maction] else []))
312     | A.Literal l -> aux_literal xmlattrs xref prec l
313     | A.UserInput -> Mpres.Mtext ([], "%")
314     | A.Layout l -> aux_layout mathonly xref  prec l
315     | A.Magic _
316     | A.Variable _ -> assert false  (* should have been instantiated *)
317     | t ->
318         prerr_endline ("unexpected ast: " ^ CicNotationPp.pp_term t);
319         assert false
320   and aux_attributes xmlattrs mathonly xref  prec t =
321     let reset = ref false in
322     let inferred_level = ref None in
323     let expected_level = ref None in
324     let new_xref = ref [] in
325     let new_xmlattrs = ref [] in
326     let rec aux_attribute =
327       function
328       | A.AttributedTerm (attr, t) ->
329           (match attr with
330           | `Loc _
331           | `Raw _ -> ()
332           | `Level (-1) -> reset := true
333           | `Level child_prec ->
334 (*               assert (!expected_level = None); *)
335               expected_level := !inferred_level;
336               inferred_level := Some child_prec
337           | `IdRef xref -> new_xref := xref :: !new_xref
338           | `XmlAttrs attrs -> new_xmlattrs := attrs @ !new_xmlattrs);
339           aux_attribute t
340       | t ->
341           let prec = 
342             match !expected_level with
343             | None -> prec
344             | Some prec -> prec
345           in
346           (match !inferred_level with
347           | None -> aux !new_xmlattrs mathonly new_xref prec t
348           | Some child_prec ->
349               let t' = aux !new_xmlattrs mathonly new_xref child_prec t in
350               (*prerr_endline 
351                 ("inferred: "^string_of_int child_prec^ 
352                  " exp: "^string_of_int prec ^ 
353                  " term: "^BoxPp.render_to_string ~map_unicode_to_tex:false
354                     (function x::_->x|_->assert false) 80 t');*)
355               if !reset
356               then ((*prerr_endline "reset";*)t')
357               else add_parens child_prec prec t')
358     in
359 (*     prerr_endline (CicNotationPp.pp_term t); *)
360     aux_attribute t
361   and aux_literal xmlattrs xref prec l =
362     let attrs = make_href xmlattrs xref in
363     (match l with
364     | `Symbol s -> Mpres.Mo (attrs, to_unicode s)
365     | `Keyword s -> Mpres.Mtext (attrs, to_unicode s)
366     | `Number s  -> Mpres.Mn (attrs, to_unicode s))
367   and aux_layout mathonly xref  prec l =
368     let attrs = make_xref xref in
369     let invoke' t = aux [] true (ref [])  prec t in
370       (* use the one below to reset precedence and associativity *)
371     let invoke_reinit t = aux [] mathonly xref ~-1 t in
372     match l with
373     | A.Sub (t1, t2) -> Mpres.Msub (attrs, invoke' t1, invoke_reinit t2)
374     | A.Sup (t1, t2) -> Mpres.Msup (attrs, invoke' t1, invoke_reinit t2)
375     | A.Below (t1, t2) -> Mpres.Munder (attrs, invoke' t1, invoke_reinit t2)
376     | A.Above (t1, t2) -> Mpres.Mover (attrs, invoke' t1, invoke_reinit t2)
377     | A.Frac (t1, t2)
378     | A.Over (t1, t2) ->
379         Mpres.Mfrac (attrs, invoke_reinit t1, invoke_reinit t2)
380     | A.Atop (t1, t2) ->
381         Mpres.Mfrac (atop_attributes @ attrs, invoke_reinit t1,
382           invoke_reinit t2)
383     | A.InfRule (t1, t2, t3) ->
384       Mpres.Mstyle ([None,"mathsize","big"],
385        Mpres.Mrow (attrs,
386         [Mpres.Mfrac ([],
387            Mpres.Mstyle ([None,"scriptlevel","0"],invoke_reinit t1),
388            Mpres.Mstyle ([None,"scriptlevel","0"],invoke_reinit t2));
389           Mpres.Mstyle ([None,"scriptlevel","2"],
390            Mpresentation.Mspace 
391             (RenderingAttrs.small_skip_attributes `MathML));
392          Mpres.Mstyle ([None,"scriptlevel","1"],invoke_reinit t3)]))
393     | A.Sqrt t -> Mpres.Msqrt (attrs, invoke_reinit t)
394     | A.Root (t1, t2) ->
395         Mpres.Mroot (attrs, invoke_reinit t1, invoke_reinit t2)
396     | A.Box ((_, spacing, _) as kind, terms) ->
397         let children =
398           aux_children mathonly spacing xref  prec
399             (CicNotationUtil.ungroup terms)
400         in
401         box_of mathonly kind attrs children
402     | A.Mstyle (l,terms) -> 
403         Mpres.Mstyle 
404           (List.map (fun (k,v) -> None,k,v) l, 
405            box_of mathonly (A.H, false, false) attrs 
406             (aux_children mathonly false xref  prec 
407               (CicNotationUtil.ungroup terms)))
408     | A.Mpadded (l,terms) -> 
409         Mpres.Mpadded 
410           (List.map (fun (k,v) -> None,k,v) l, 
411            box_of mathonly (A.H, false, false) attrs 
412             (aux_children mathonly false xref  prec 
413               (CicNotationUtil.ungroup terms)))
414     | A.Group terms ->
415         let children =
416           aux_children mathonly false xref  prec
417             (CicNotationUtil.ungroup terms)
418         in
419         box_of mathonly (A.H, false, false) attrs children
420     | A.Break -> assert false (* TODO? *)
421   and aux_children mathonly spacing xref  prec terms =
422     let find_clusters =
423       let rec aux_list first clusters acc =
424         function
425             [] when acc = [] -> List.rev clusters
426           | [] -> aux_list first (List.rev acc :: clusters) [] []
427           | (A.Layout A.Break) :: tl when acc = [] ->
428               aux_list first clusters [] tl
429           | (A.Layout A.Break) :: tl ->
430               aux_list first (List.rev acc :: clusters) [] tl
431           | [hd] ->
432                 aux_list false clusters
433                   (aux [] mathonly xref  prec hd :: acc) []
434           | hd :: tl ->
435                 aux_list false clusters
436                   (aux [] mathonly xref  prec hd :: acc) tl
437       in
438         aux_list true [] []
439     in
440     let boxify_pres =
441       function
442           [t] -> t
443         | tl -> box_of mathonly (A.H, spacing, false) [] tl
444     in
445       List.map boxify_pres (find_clusters terms)
446   in
447   aux [] false (ref []) prec
448
449 let rec print_box (t: boxml_markup) =
450   Box.box2xml print_mpres t
451 and print_mpres (t: mathml_markup) =
452   Mpresentation.print_mpres print_box t
453
454 let print_xml = print_mpres
455
456 (* let render_to_boxml id_to_uri t =
457   let xml_stream = print_box (box_of_mpres (render id_to_uri t)) in
458   Xml.add_xml_declaration xml_stream *)
459