X-Git-Url: http://matita.cs.unibo.it/gitweb/?a=blobdiff_plain;f=helm%2Fsoftware%2Fcomponents%2Fcontent_pres%2FcicNotationParser.ml;h=587c22e4a07b8b9a39fea3225069c4a73454e01f;hb=f9abd21eb0d26cf9b632af4df819225be4d091e3;hp=aca53578b1fb9c7ca0beff072d14c2e7dbcaacf4;hpb=d063ddede0424eb1f47a4c9769eaefbb16d90700;p=helm.git diff --git a/helm/software/components/content_pres/cicNotationParser.ml b/helm/software/components/content_pres/cicNotationParser.ml index aca53578b..587c22e4a 100644 --- a/helm/software/components/content_pres/cicNotationParser.ml +++ b/helm/software/components/content_pres/cicNotationParser.ml @@ -33,21 +33,45 @@ module Env = CicNotationEnv exception Parse_error of string exception Level_not_found of int -let level1_pattern_grammar = - Grammar.gcreate CicNotationLexer.level1_pattern_lexer -let level2_ast_grammar = Grammar.gcreate CicNotationLexer.level2_ast_lexer -let level2_meta_grammar = Grammar.gcreate CicNotationLexer.level2_meta_lexer - let min_precedence = 0 let max_precedence = 100 -let level1_pattern = - Grammar.Entry.create level1_pattern_grammar "level1_pattern" -let level2_ast = Grammar.Entry.create level2_ast_grammar "level2_ast" -let term = Grammar.Entry.create level2_ast_grammar "term" -let let_defs = Grammar.Entry.create level2_ast_grammar "let_defs" -let protected_binder_vars = Grammar.Entry.create level2_ast_grammar "protected_binder_vars" -let level2_meta = Grammar.Entry.create level2_meta_grammar "level2_meta" +type ('a,'b,'c,'d) grammars = { + level1_pattern: 'a Grammar.Entry.e; + level2_ast: 'b Grammar.Entry.e; + level2_ast_grammar : Grammar.g; + term: 'b Grammar.Entry.e; + let_defs: 'c Grammar.Entry.e; + protected_binder_vars: 'd Grammar.Entry.e; + level2_meta: 'b Grammar.Entry.e; +} + +let initial_grammars () = + let level1_pattern_grammar = + Grammar.gcreate (CicNotationLexer.level1_pattern_lexer ()) in + let level2_ast_grammar = + Grammar.gcreate (CicNotationLexer.level2_ast_lexer ()) in + let level2_meta_grammar = + Grammar.gcreate (CicNotationLexer.level2_meta_lexer ()) in + let level1_pattern = + Grammar.Entry.create level1_pattern_grammar "level1_pattern" in + let level2_ast = Grammar.Entry.create level2_ast_grammar "level2_ast" in + let term = Grammar.Entry.create level2_ast_grammar "term" in + let let_defs = Grammar.Entry.create level2_ast_grammar "let_defs" in + let protected_binder_vars = + Grammar.Entry.create level2_ast_grammar "protected_binder_vars" in + let level2_meta = Grammar.Entry.create level2_meta_grammar "level2_meta" in + { level1_pattern=level1_pattern; + level2_ast=level2_ast; + term=term; + let_defs=let_defs; + protected_binder_vars=protected_binder_vars; + level2_meta=level2_meta; + level2_ast_grammar=level2_ast_grammar; +} +;; + +let grammars = ref (initial_grammars ());; let int_of_string s = try @@ -70,7 +94,8 @@ let gram_term = function | Ast.Self _ -> Gramext.Sself | Ast.Level precedence -> Gramext.Snterml - (Grammar.Entry.obj (term: 'a Grammar.Entry.e), level_of precedence) + (Grammar.Entry.obj (!grammars.term: 'a Grammar.Entry.e), + level_of precedence) ;; let gram_of_literal = @@ -145,21 +170,24 @@ let extract_term_production pattern = [NoBinding, gram_keyword s] | `Number s -> [NoBinding, gram_number s] and aux_layout = function - | Ast.Sub (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\sub"] @ aux p2 - | Ast.Sup (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\sup"] @ aux p2 - | Ast.Below (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\below"] @ aux p2 - | Ast.Above (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\above"] @ aux p2 - | Ast.Frac (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\frac"] @ aux p2 - | Ast.InfRule (p1, p2, p3) -> aux p1 @ [NoBinding, gram_symbol "\\infrule"] @ aux p2 @ aux p3 - | Ast.Atop (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\atop"] @ aux p2 - | Ast.Over (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\over"] @ aux p2 + | Ast.Sub (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\sub "] @ aux p2 + | Ast.Sup (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\sup "] @ aux p2 + | Ast.Below (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\below "] @ aux p2 + | Ast.Above (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\above "] @ aux p2 + | Ast.Frac (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\frac "] @ aux p2 + | Ast.InfRule (p1, p2, p3) -> [NoBinding, gram_symbol "\\infrule "] @ aux p1 @ aux p2 @ aux p3 + | Ast.Atop (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\atop "] @ aux p2 + | Ast.Over (p1, p2) -> aux p1 @ [NoBinding, gram_symbol "\\over "] @ aux p2 | Ast.Root (p1, p2) -> - [NoBinding, gram_symbol "\\root"] @ aux p2 - @ [NoBinding, gram_symbol "\\of"] @ aux p1 - | Ast.Sqrt p -> [NoBinding, gram_symbol "\\sqrt"] @ aux p + [NoBinding, gram_symbol "\\root "] @ aux p2 + @ [NoBinding, gram_symbol "\\of "] @ aux p1 + | Ast.Sqrt p -> [NoBinding, gram_symbol "\\sqrt "] @ aux p | Ast.Break -> [] | Ast.Box (_, pl) -> List.flatten (List.map aux pl) | Ast.Group pl -> List.flatten (List.map aux pl) + | Ast.Mstyle (_,pl) -> List.flatten (List.map aux pl) + | Ast.Mpadded (_,pl) -> List.flatten (List.map aux pl) + | Ast.Maction l -> List.flatten (List.map aux l) and aux_magic magic = match magic with | Ast.Opt p -> @@ -183,8 +211,8 @@ let extract_term_production pattern = match magic with | Ast.List0 (_, None) -> Gramext.Slist0 s | Ast.List1 (_, None) -> Gramext.Slist1 s - | Ast.List0 (_, Some l) -> Gramext.Slist0sep (s, gram_of_literal l) - | Ast.List1 (_, Some l) -> Gramext.Slist1sep (s, gram_of_literal l) + | Ast.List0 (_, Some l) -> Gramext.Slist0sep (s, gram_of_literal l, false) + | Ast.List1 (_, Some l) -> Gramext.Slist1sep (s, gram_of_literal l, false) | _ -> assert false in [ Env (List.map Env.list_declaration p_names), @@ -213,12 +241,29 @@ let extract_term_production pattern = type rule_id = Grammar.token Gramext.g_symbol list +let compare_rule_id x y = + let rec aux = function + | [],[] -> 0 + | [],_ -> ~-1 + | _,[] -> 1 + | ((s1::tl1) ),((s2::tl2) ) -> + if Gramext.eq_symbol s1 s2 then aux (tl1,tl2) + else + let res = + try Pervasives.compare s1 s2 + with Invalid_argument _ -> 0 + in + if res = 0 then aux (tl1, tl2) else res + in + aux (x,y) + (* mapping: rule_id -> owned keywords. (rule_id, string list) Hashtbl.t *) -let owned_keywords = Hashtbl.create 23 +let initial_owned_keywords () = Hashtbl.create 23 +let owned_keywords = ref (initial_owned_keywords ()) type checked_l1_pattern = CL1P of CicNotationPt.term * int -let check_l1_pattern level1_pattern level associativity = +let check_l1_pattern level1_pattern pponly level associativity = let variables = ref 0 in let symbols = ref 0 in let rec aux = function @@ -242,6 +287,12 @@ let check_l1_pattern level1_pattern level associativity = | Ast.Break as t -> t | Ast.Box (b, pl) -> Ast.Box(b, List.map aux pl) | Ast.Group pl -> Ast.Group (List.map aux pl) + | Ast.Mstyle (l,pl) -> Ast.Mstyle (l, List.map aux pl) + | Ast.Mpadded (l,pl) -> Ast.Mpadded (l, List.map aux pl) + | Ast.Maction l as t -> + if not pponly then + raise(Parse_error("Maction can be used only in output notations")) + else t and aux_magic magic = match magic with | Ast.Opt p -> Ast.Opt (aux p) @@ -296,7 +347,7 @@ let extend (CL1P (level1_pattern,precedence)) action = let level = level_of precedence in let _ = Grammar.extend - [ Grammar.Entry.obj (term: 'a Grammar.Entry.e), + [ Grammar.Entry.obj (!grammars.term: 'a Grammar.Entry.e), Some (Gramext.Level level), [ None, Some (*Gramext.NonA*) Gramext.NonA, @@ -309,16 +360,16 @@ let extend (CL1P (level1_pattern,precedence)) action = let keywords = CicNotationUtil.keywords_of_term level1_pattern in let rule_id = p_atoms in List.iter CicNotationLexer.add_level2_ast_keyword keywords; - Hashtbl.add owned_keywords rule_id keywords; (* keywords may be [] *) + Hashtbl.add !owned_keywords rule_id keywords; (* keywords may be [] *) rule_id let delete rule_id = let atoms = rule_id in (try - let keywords = Hashtbl.find owned_keywords rule_id in + let keywords = Hashtbl.find !owned_keywords rule_id in List.iter CicNotationLexer.remove_level2_ast_keyword keywords with Not_found -> assert false); - Grammar.delete_rule term atoms + Grammar.delete_rule !grammars.term atoms (** {2 Grammar} *) @@ -348,7 +399,7 @@ let return_term_of_level loc term l = Ast.AttributedTerm (`Loc loc, term l) (* create empty precedence level for "term" *) -let _ = +let initialize_grammars () = let dummy_action = Gramext.action (fun _ -> failwith "internal error, lexer generated a dummy token") @@ -368,11 +419,12 @@ let _ = aux [] last in Grammar.extend - [ Grammar.Entry.obj (term: 'a Grammar.Entry.e), + [ Grammar.Entry.obj (!grammars.term: 'a Grammar.Entry.e), None, - mk_level_list min_precedence max_precedence ] - + mk_level_list min_precedence max_precedence ]; (* {{{ Grammar for concrete syntax patterns, notation level 1 *) + begin + let level1_pattern = !grammars.level1_pattern in EXTEND GLOBAL: level1_pattern; @@ -405,35 +457,41 @@ EXTEND | "ident"; id = IDENT -> Ast.IdentVar id ] ]; + mstyle: [ + [ id = IDENT; + v = [ IDENT | NUMBER | COLOR | FLOATWITHUNIT ] -> id, v]]; + mpadded: [ + [ id = IDENT; + v = [ PERCENTAGE ] -> id, v]]; l1_simple_pattern: [ "layout" LEFTA - [ p1 = SELF; SYMBOL "\\sub"; p2 = SELF -> + [ p1 = SELF; SYMBOL "\\sub "; p2 = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.Sub (p1 l, p2 l))) - | p1 = SELF; SYMBOL "\\sup"; p2 = SELF -> + | p1 = SELF; SYMBOL "\\sup "; p2 = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.Sup (p1 l, p2 l))) - | p1 = SELF; SYMBOL "\\below"; p2 = SELF -> + | p1 = SELF; SYMBOL "\\below "; p2 = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.Below (p1 l, p2 l))) - | p1 = SELF; SYMBOL "\\above"; p2 = SELF -> + | p1 = SELF; SYMBOL "\\above "; p2 = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.Above (p1 l, p2 l))) - | p1 = SELF; SYMBOL "\\over"; p2 = SELF -> + | p1 = SELF; SYMBOL "\\over "; p2 = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.Over (p1 l, p2 l))) - | p1 = SELF; SYMBOL "\\atop"; p2 = SELF -> + | p1 = SELF; SYMBOL "\\atop "; p2 = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.Atop (p1 l, p2 l))) - | SYMBOL "\\frac"; p1 = SELF; p2 = SELF -> + | p1 = SELF; SYMBOL "\\frac "; p2 = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.Frac (p1 l, p2 l))) - | SYMBOL "\\infrule"; p1 = SELF; p2 = SELF; p3 = SELF -> + | SYMBOL "\\infrule "; p1 = SELF; p2 = SELF; p3 = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.InfRule (p1 l, p2 l, p3 l))) - | SYMBOL "\\sqrt"; p = SELF -> + | SYMBOL "\\sqrt "; p = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.Sqrt p l)) - | SYMBOL "\\root"; index = SELF; SYMBOL "\\of"; arg = SELF -> + | SYMBOL "\\root "; index = SELF; SYMBOL "\\of "; arg = SELF -> return_term_of_level loc (fun l -> Ast.Layout (Ast.Root (arg l, index l))) | "hbox"; LPAREN; p = l1_pattern; RPAREN -> @@ -449,6 +507,18 @@ EXTEND return_term_of_level loc (fun l -> Ast.Layout (Ast.Box ((Ast.HOV, false, false), p l))) | "break" -> return_term_of_level loc (fun _ -> Ast.Layout Ast.Break) + | "mstyle"; m = LIST1 mstyle ; LPAREN; t = l1_pattern; RPAREN -> + return_term_of_level loc + (fun l -> + Ast.Layout (Ast.Mstyle (m, t l))) + | "mpadded"; m = LIST1 mpadded ; LPAREN; t = l1_pattern; RPAREN -> + return_term_of_level loc + (fun l -> + Ast.Layout (Ast.Mpadded (m, t l))) + | "maction"; m = LIST1 [ LPAREN; l = l1_pattern; RPAREN -> l ] -> + return_term_of_level loc + (fun l -> Ast.Layout (Ast.Maction (List.map (fun x -> + CicNotationUtil.group (x l)) m))) | LPAREN; p = l1_pattern; RPAREN -> return_term_of_level loc (fun l -> CicNotationUtil.group (p l)) ] @@ -464,9 +534,11 @@ EXTEND ] ]; END + end; (* }}} *) - (* {{{ Grammar for ast magics, notation level 2 *) + begin + let level2_meta = !grammars.level2_meta in EXTEND GLOBAL: level2_meta; l2_variable: [ @@ -500,21 +572,28 @@ EXTEND ] ]; END + end; (* }}} *) - (* {{{ Grammar for ast patterns, notation level 2 *) + begin + let level2_ast = !grammars.level2_ast in + let term = !grammars.term in + let let_defs = !grammars.let_defs in + let protected_binder_vars = !grammars.protected_binder_vars in EXTEND GLOBAL: level2_ast term let_defs protected_binder_vars; level2_ast: [ [ p = term -> p ] ]; sort: [ [ "Prop" -> `Prop | "Set" -> `Set + | "Type"; SYMBOL "["; n = [ NUMBER| IDENT ]; SYMBOL "]" -> `NType n | "Type" -> `Type (CicUniv.fresh ()) + | "CProp"; SYMBOL "["; n = [ NUMBER| IDENT ]; SYMBOL "]" -> `NCProp n | "CProp" -> `CProp (CicUniv.fresh ()) ] ]; explicit_subst: [ - [ SYMBOL "\\subst"; (* to avoid catching frequent "a [1]" cases *) + [ SYMBOL "\\subst "; (* to avoid catching frequent "a [1]" cases *) SYMBOL "["; substs = LIST1 [ i = IDENT; SYMBOL <:unicode> (* ≔ *); t = term -> (i, t) @@ -534,23 +613,25 @@ EXTEND [ LPAREN; id = single_arg; SYMBOL ":"; typ = term; RPAREN -> id, Some typ | arg = single_arg -> arg, None + | id = PIDENT -> Ast.Ident (id, None), None | SYMBOL "_" -> Ast.Ident ("_", None), None + | LPAREN; id = PIDENT; SYMBOL ":"; typ = term; RPAREN -> + Ast.Ident (id, None), Some typ | LPAREN; SYMBOL "_"; SYMBOL ":"; typ = term; RPAREN -> Ast.Ident ("_", None), Some typ ] ]; match_pattern: [ - [ id = IDENT -> Ast.Pattern (id, None, []) + [ SYMBOL "_" -> Ast.Wildcard + | id = IDENT -> Ast.Pattern (id, None, []) | LPAREN; id = IDENT; vars = LIST1 possibly_typed_name; RPAREN -> Ast.Pattern (id, None, vars) | id = IDENT; vars = LIST1 possibly_typed_name -> Ast.Pattern (id, None, vars) - | SYMBOL "_" -> Ast.Wildcard ] ]; binder: [ [ SYMBOL <:unicode> (* Π *) -> `Pi -(* | SYMBOL <:unicode> |+ ∃ +| -> `Exists *) | SYMBOL <:unicode> (* ∀ *) -> `Forall | SYMBOL <:unicode> (* λ *) -> `Lambda ] @@ -617,9 +698,11 @@ EXTEND ] ]; binder_vars: [ - [ vars = [ - l = LIST1 single_arg SEP SYMBOL "," -> l - | SYMBOL "_" -> [Ast.Ident ("_", None)] ]; + [ vars = [ l = + [ l = LIST1 single_arg SEP SYMBOL "," -> l + | l = LIST1 [ PIDENT | SYMBOL "_" ] SEP SYMBOL "," -> + List.map (fun x -> Ast.Ident(x,None)) l + ] -> l ]; typ = OPT [ SYMBOL ":"; t = term -> t ] -> (vars, typ) ] ]; @@ -634,7 +717,13 @@ EXTEND ]; term: LEVEL "10" [ - [ "let"; var = possibly_typed_name; SYMBOL <:unicode> (* ≝ *); + [ "let"; + var = + [ LPAREN; id = single_arg; SYMBOL ":"; typ = term; RPAREN -> + id, Some typ + | id = IDENT; ty = OPT [ SYMBOL ":"; typ = term -> typ] -> + Ast.Ident(id,None), ty ]; + SYMBOL <:unicode> (* ≝ *); p1 = term; "in"; p2 = term -> return_term loc (Ast.LetIn (var, p1, p2)) | LETCOREC; defs = let_defs; "in"; @@ -649,9 +738,6 @@ EXTEND [ [ b = binder; (vars, typ) = maybe_protected_binder_vars; SYMBOL "."; body = term LEVEL "19" -> return_term loc (fold_cluster b vars typ body) - | SYMBOL <:unicode> (* ∃ *); - (vars, typ) = maybe_protected_binder_vars; SYMBOL "."; body = term LEVEL "19"-> - return_term loc (fold_exists vars typ body) ] ]; term: LEVEL "70" @@ -673,8 +759,10 @@ EXTEND return_term loc (Ast.Ident (id, Some s)) | s = CSYMBOL -> return_term loc (Ast.Symbol (s, 0)) | u = URI -> return_term loc (Ast.Uri (u, None)) + | r = NREF -> return_term loc (Ast.NRef (NReference.reference_of_string r)) | n = NUMBER -> return_term loc (Ast.Num (n, 0)) - | IMPLICIT -> return_term loc (Ast.Implicit) + | IMPLICIT -> return_term loc (Ast.Implicit `JustOne) + | SYMBOL <:unicode> -> return_term loc (Ast.Implicit `Vector) | PLACEHOLDER -> return_term loc Ast.UserInput | m = META -> return_term loc (Ast.Meta (int_of_string m, [])) | m = META; s = meta_substs -> @@ -699,7 +787,31 @@ EXTEND ] ]; END + end (* }}} *) +;; + +let _ = initialize_grammars ();; + +let history = ref [];; + +let push () = + CicNotationLexer.push (); + history := (!owned_keywords,!grammars) :: !history; + owned_keywords := (initial_owned_keywords ()); + grammars := initial_grammars (); + initialize_grammars () +;; + +let pop () = + CicNotationLexer.pop (); + match !history with + | [] -> assert false + | (kw,gram) :: old_history -> + owned_keywords := kw; + grammars := gram; + history := old_history +;; (** {2 API implementation} *) @@ -707,22 +819,24 @@ let exc_located_wrapper f = try f () with - | Stdpp.Exc_located (floc, Stream.Error msg) -> + | Ploc.Exc (floc, Stream.Error msg) -> raise (HExtlib.Localized (floc, Parse_error msg)) - | Stdpp.Exc_located (floc, exn) -> + | Ploc.Exc (floc, HExtlib.Localized (_,exn)) -> + raise (HExtlib.Localized (floc, (Parse_error (Printexc.to_string exn)))) + | Ploc.Exc (floc, exn) -> raise (HExtlib.Localized (floc, (Parse_error (Printexc.to_string exn)))) let parse_level1_pattern precedence lexbuf = exc_located_wrapper - (fun () -> Grammar.Entry.parse level1_pattern (Obj.magic lexbuf) precedence) + (fun () -> Grammar.Entry.parse !grammars.level1_pattern (Obj.magic lexbuf) precedence) let parse_level2_ast lexbuf = exc_located_wrapper - (fun () -> Grammar.Entry.parse level2_ast (Obj.magic lexbuf)) + (fun () -> Grammar.Entry.parse !grammars.level2_ast (Obj.magic lexbuf)) let parse_level2_meta lexbuf = exc_located_wrapper - (fun () -> Grammar.Entry.parse level2_meta (Obj.magic lexbuf)) + (fun () -> Grammar.Entry.parse !grammars.level2_meta (Obj.magic lexbuf)) let _ = parse_level1_pattern_ref := parse_level1_pattern; @@ -731,13 +845,19 @@ let _ = let parse_term lexbuf = exc_located_wrapper - (fun () -> (Grammar.Entry.parse term (Obj.magic lexbuf))) + (fun () -> (Grammar.Entry.parse !grammars.term (Obj.magic lexbuf))) + +let level2_ast_grammar () = !grammars.level2_ast_grammar +let term () = !grammars.term +let let_defs () = !grammars.let_defs +let protected_binder_vars () = !grammars.protected_binder_vars + (** {2 Debugging} *) let print_l2_pattern () = - Grammar.print_entry Format.std_formatter (Grammar.Entry.obj term); + Grammar.print_entry Format.std_formatter (Grammar.Entry.obj !grammars.term); Format.pp_print_flush Format.std_formatter (); - flush stdout + flush stdout (* vim:set encoding=utf8 foldmethod=marker: *)