Remove the non-functorial interface of camlp5 grammars.

2 files changed, 0 insertions, 177 deletions

diff --git a/gramlib/grammar.ml b/gramlib/grammar.ml
index 5340482a01..760410894a 100644
--- a/gramlib/grammar.ml
+++ b/gramlib/grammar.ml
@@ -781,13 +781,6 @@ let delete_rule entry sl =
 
 (* Normal interface *)
 
-type token = string * string
-type g = token Gramext.grammar
-
-type ('self, 'a) ty_symbol = token Gramext.g_symbol
-type ('self, 'f, 'r) ty_rule = ('self, Obj.t) ty_symbol list
-type 'a ty_production = ('a, Obj.t, Obj.t) ty_rule * Gramext.g_action
-
 let create_toktab () = Hashtbl.create 301
 let gcreate glexer =
   {gtokens = create_toktab (); glexer = glexer }
@@ -806,12 +799,6 @@ type 'te gen_parsable =
     pa_tok_strm : 'te Stream.t;
     pa_loc_func : Plexing.location_function }
 
-type parsable = token gen_parsable
-
-let parsable g cs =
-  let (ts, lf) = g.glexer.Plexing.tok_func cs in
-  {pa_chr_strm = cs; pa_tok_strm = ts; pa_loc_func = lf}
-
 let parse_parsable entry p =
   let efun = entry.estart 0 in
   let ts = p.pa_tok_strm in
@@ -843,93 +830,6 @@ let parse_parsable entry p =
       let loc = Stream.count cs, Stream.count cs + 1 in
       restore (); Ploc.raise (Ploc.make_unlined loc) exc
 
-let find_entry e s =
-  let rec find_levels =
-    function
-      [] -> None
-    | lev :: levs ->
-        match find_tree lev.lsuffix with
-          None ->
-            begin match find_tree lev.lprefix with
-              None -> find_levels levs
-            | x -> x
-            end
-        | x -> x
-  and find_symbol =
-    function
-    | Snterm e -> if e.ename = s then Some e else None
-    | Snterml (e, _) -> if e.ename = s then Some e else None
-    | Slist0 s -> find_symbol s
-    | Slist0sep (s, _, _) -> find_symbol s
-    | Slist1 s -> find_symbol s
-    | Slist1sep (s, _, _) -> find_symbol s
-    | Sopt s -> find_symbol s
-    | Stree t -> find_tree t
-    | Sself | Snext | Stoken _ -> None
-  and find_tree =
-    function
-      Node {node = s; brother = bro; son = son} ->
-        begin match find_symbol s with
-          None ->
-            begin match find_tree bro with
-              None -> find_tree son
-            | x -> x
-            end
-        | x -> x
-        end
-    | LocAct (_, _) | DeadEnd -> None
-  in
-  match e.edesc with
-    Dlevels levs ->
-      begin match find_levels levs with
-        Some e -> e
-      | None -> raise Not_found
-      end
-  | Dparser _ -> raise Not_found
-module Entry =
-  struct
-    type te = token
-    type 'a e = te g_entry
-    let create g n =
-      {egram = g; ename = n; elocal = false; estart = empty_entry n;
-       econtinue = (fun _ _ _ (strm__ : _ Stream.t) -> raise Stream.Failure);
-       edesc = Dlevels []}
-    let parse_parsable (entry : 'a e) p : 'a =
-      Obj.magic (parse_parsable entry p : Obj.t)
-    let parse (entry : 'a e) cs : 'a =
-      let parsable = parsable entry.egram cs in parse_parsable entry parsable
-    let parse_parsable_all (entry : 'a e) p : 'a =
-      begin try Obj.magic [(parse_parsable entry p : Obj.t)] with
-          Stream.Failure | Stream.Error _ -> []
-      end
-    let parse_all (entry : 'a e) cs : 'a =
-      let parsable = parsable entry.egram cs in
-      parse_parsable_all entry parsable
-    let parse_token_stream (entry : 'a e) ts : 'a =
-      Obj.magic (entry.estart 0 ts : Obj.t)
-    let _warned_using_parse_token = ref false
-    let parse_token (entry : 'a e) ts : 'a =
-      (* commented: too often warned in Coq...
-      if not warned_using_parse_token.val then do {
-        eprintf "<W> use of Grammar.Entry.parse_token ";
-        eprintf "deprecated since 2017-06-16\n%!";
-        eprintf "use Grammar.Entry.parse_token_stream instead\n%! ";
-        warned_using_parse_token.val := True
-      }
-      else ();
-      *)
-      parse_token_stream entry ts
-    let name e = e.ename
-    let of_parser g n (p : te Stream.t -> 'a) : 'a e =
-      {egram = g; ename = n; elocal = false;
-       estart = (fun _ -> (Obj.magic p : te Stream.t -> Obj.t));
-       econtinue = (fun _ _ _ (strm__ : _ Stream.t) -> raise Stream.Failure);
-       edesc = Dparser (Obj.magic p : te Stream.t -> Obj.t)}
-    external obj : 'a e -> te Gramext.g_entry = "%identity"
-    let print ppf e = fprintf ppf "%a@." print_entry (obj e)
-    let find e s = find_entry (obj e) s
-  end
-
 (* Unsafe *)
 
 let clear_entry e =
@@ -941,12 +841,6 @@ let clear_entry e =
 
 let gram_reinit g glexer = Hashtbl.clear g.gtokens; g.glexer <- glexer
 
-module Unsafe =
-  struct
-    let gram_reinit = gram_reinit
-    let clear_entry = clear_entry
-  end
-
 (* Functorial interface *)
 
 module type GLexerType = sig type te val lexer : te Plexing.lexer end
diff --git a/gramlib/grammar.mli b/gramlib/grammar.mli
index 53c8004a5b..244ab710dc 100644
--- a/gramlib/grammar.mli
+++ b/gramlib/grammar.mli
@@ -8,77 +8,6 @@
     Grammars entries can be extended using the [EXTEND] statement,
     added by loading the Camlp5 [pa_extend.cmo] file. *)
 
-type g
-   (** The type for grammars, holding entries. *)
-type token = string * string
-
-type parsable
-val parsable : g -> char Stream.t -> parsable
-   (** Type and value allowing to keep the same token stream between
-       several calls of entries of the same grammar, to prevent possible
-       loss of tokens. To be used with [Entry.parse_parsable] below *)
-
-module Entry :
-  sig
-    type 'a e
-    val create : g -> string -> 'a e
-    val parse : 'a e -> char Stream.t -> 'a
-    val parse_all : 'a e -> char Stream.t -> 'a list
-    val parse_parsable : 'a e -> parsable -> 'a
-    val name : 'a e -> string
-    val of_parser : g -> string -> (token Stream.t -> 'a) -> 'a e
-    val parse_token_stream : 'a e -> token Stream.t -> 'a
-    val print : Format.formatter -> 'a e -> unit
-    val find : 'a e -> string -> Obj.t e
-    external obj : 'a e -> token Gramext.g_entry = "%identity"
-    val parse_token : 'a e -> token Stream.t -> 'a
-  end
-   (** Module to handle entries.
--      [Entry.e] is the type for entries returning values of type ['a].
--      [Entry.create g n] creates a new entry named [n] in the grammar [g].
--      [Entry.parse e] returns the stream parser of the entry [e].
--      [Entry.parse_all e] returns the stream parser returning all possible
-          values while parsing with the entry [e]: may return more than one
-          value when the parsing algorithm is [Backtracking]
--      [Entry.parse_all e] returns the parser returning all possible values.
--      [Entry.parse_parsable e] returns the parsable parser of the entry [e].
--      [Entry.name e] returns the name of the entry [e].
--      [Entry.of_parser g n p] makes an entry from a token stream parser.
--      [Entry.parse_token_stream e] returns the token stream parser of the
-          entry [e].
--      [Entry.print e] displays the entry [e] using [Format].
--      [Entry.find e s] finds the entry named [s] in the rules of [e].
--      [Entry.obj e] converts an entry into a [Gramext.g_entry] allowing
-          to see what it holds.
--      [Entry.parse_token]: deprecated since 2017-06-16; old name for
-          [Entry.parse_token_stream] *)
-
-type ('self, 'a) ty_symbol
-(** Type of grammar symbols. A type-safe wrapper around Gramext.symbol. The
-    first type argument is the type of the ambient entry, the second one is the
-    type of the produced value. *)
-
-type ('self, 'f, 'r) ty_rule
-
-type 'a ty_production
-
-(** {6 Clearing grammars and entries} *)
-
-module Unsafe :
-  sig
-    val gram_reinit : g -> token Plexing.lexer -> unit
-    val clear_entry : 'a Entry.e -> unit
-  end
-   (** Module for clearing grammars and entries. To be manipulated with
-       care, because: 1) reinitializing a grammar destroys all tokens
-       and there may have problems with the associated lexer if there
-       are keywords; 2) clearing an entry does not destroy the tokens
-       used only by itself.
--      [Unsafe.reinit_gram g lex] removes the tokens of the grammar
--      and sets [lex] as a new lexer for [g]. Warning: the lexer
--      itself is not reinitialized.
--      [Unsafe.clear_entry e] removes all rules of the entry [e]. *)
-
 (** {6 Functorial interface} *)
 
    (** Alternative for grammars use. Grammars are no more Ocaml values: