sig
  module type Action =
    sig
      type t
      val mk : 'a -> Camlp4.Sig.Grammar.Action.t
      val get : Camlp4.Sig.Grammar.Action.t -> 'a
      val getf : Camlp4.Sig.Grammar.Action.t -> 'a -> 'b
      val getf2 : Camlp4.Sig.Grammar.Action.t -> 'a -> 'b -> 'c
    end
  type assoc = NonA | RightA | LeftA
  type position =
      First
    | Last
    | Before of string
    | After of string
    | Level of string
  module type Structure =
    sig
      module Loc : Loc
      module Action : Action
      module Token :
        sig
          module Loc :
            sig
              type t = Loc.t
              val mk : string -> t
              val ghost : t
              val of_lexing_position : Lexing.position -> t
              val to_ocaml_location : t -> Camlp4_import.Location.t
              val of_ocaml_location : Camlp4_import.Location.t -> t
              val of_lexbuf : Lexing.lexbuf -> t
              val of_tuple :
                string * int * int * int * int * int * int * bool -> t
              val to_tuple :
                t -> string * int * int * int * int * int * int * bool
              val merge : t -> t -> t
              val join : t -> t
              val move : [ `both | `start | `stop ] -> int -> t -> t
              val shift : int -> t -> t
              val move_line : int -> t -> t
              val file_name : t -> string
              val start_line : t -> int
              val stop_line : t -> int
              val start_bol : t -> int
              val stop_bol : t -> int
              val start_off : t -> int
              val stop_off : t -> int
              val start_pos : t -> Lexing.position
              val stop_pos : t -> Lexing.position
              val is_ghost : t -> bool
              val ghostify : t -> t
              val set_file_name : string -> t -> t
              val strictly_before : t -> t -> bool
              val make_absolute : t -> t
              val print : Format.formatter -> t -> unit
              val dump : Format.formatter -> t -> unit
              val to_string : t -> string
              exception Exc_located of t * exn
              val raise : t -> exn -> 'a
              val name : string ref
            end
          type t
          val to_string : t -> string
          val print : Format.formatter -> t -> unit
          val match_keyword : string -> t -> bool
          val extract_string : t -> string
          module Filter :
            sig
              type token_filter = (t, Loc.t) stream_filter
              type t
              val mk : (string -> bool) -> t
              val define_filter : t -> (token_filter -> token_filter) -> unit
              val filter : t -> token_filter
              val keyword_added : t -> string -> bool -> unit
              val keyword_removed : t -> string -> unit
            end
          module Error : Error
        end
      type gram
      type internal_entry
      type tree
      type token_pattern =
          (Camlp4.Sig.Grammar.Structure.Token.t -> bool) * string
      type token_info
      type token_stream =
          (Camlp4.Sig.Grammar.Structure.Token.t *
           Camlp4.Sig.Grammar.Structure.token_info)
          Stream.t
      val token_location :
        Camlp4.Sig.Grammar.Structure.token_info -> Camlp4.Sig.Loc.t
      type symbol =
          Smeta of string * Camlp4.Sig.Grammar.Structure.symbol list *
            Camlp4.Sig.Grammar.Action.t
        | Snterm of Camlp4.Sig.Grammar.Structure.internal_entry
        | Snterml of Camlp4.Sig.Grammar.Structure.internal_entry * string
        | Slist0 of Camlp4.Sig.Grammar.Structure.symbol
        | Slist0sep of Camlp4.Sig.Grammar.Structure.symbol *
            Camlp4.Sig.Grammar.Structure.symbol
        | Slist1 of Camlp4.Sig.Grammar.Structure.symbol
        | Slist1sep of Camlp4.Sig.Grammar.Structure.symbol *
            Camlp4.Sig.Grammar.Structure.symbol
        | Sopt of Camlp4.Sig.Grammar.Structure.symbol
        | Stry of Camlp4.Sig.Grammar.Structure.symbol
        | Sself
        | Snext
        | Stoken of Camlp4.Sig.Grammar.Structure.token_pattern
        | Skeyword of string
        | Stree of Camlp4.Sig.Grammar.Structure.tree
      type production_rule =
          Camlp4.Sig.Grammar.Structure.symbol list *
          Camlp4.Sig.Grammar.Action.t
      type single_extend_statment =
          string option * Camlp4.Sig.Grammar.assoc option *
          Camlp4.Sig.Grammar.Structure.production_rule list
      type extend_statment =
          Camlp4.Sig.Grammar.position option *
          Camlp4.Sig.Grammar.Structure.single_extend_statment list
      type delete_statment = Camlp4.Sig.Grammar.Structure.symbol list
      type ('a, 'b, 'c) fold =
          Camlp4.Sig.Grammar.Structure.internal_entry ->
          Camlp4.Sig.Grammar.Structure.symbol list ->
          ('a Stream.t -> 'b) -> 'a Stream.t -> 'c
      type ('a, 'b, 'c) foldsep =
          Camlp4.Sig.Grammar.Structure.internal_entry ->
          Camlp4.Sig.Grammar.Structure.symbol list ->
          ('a Stream.t -> 'b) -> ('a Stream.t -> unit) -> 'a Stream.t -> 'c
    end
  module type Dynamic =
    sig
      module Loc : Loc
      module Action : Action
      module Token :
        sig
          module Loc :
            sig
              type t = Loc.t
              val mk : string -> t
              val ghost : t
              val of_lexing_position : Lexing.position -> t
              val to_ocaml_location : t -> Camlp4_import.Location.t
              val of_ocaml_location : Camlp4_import.Location.t -> t
              val of_lexbuf : Lexing.lexbuf -> t
              val of_tuple :
                string * int * int * int * int * int * int * bool -> t
              val to_tuple :
                t -> string * int * int * int * int * int * int * bool
              val merge : t -> t -> t
              val join : t -> t
              val move : [ `both | `start | `stop ] -> int -> t -> t
              val shift : int -> t -> t
              val move_line : int -> t -> t
              val file_name : t -> string
              val start_line : t -> int
              val stop_line : t -> int
              val start_bol : t -> int
              val stop_bol : t -> int
              val start_off : t -> int
              val stop_off : t -> int
              val start_pos : t -> Lexing.position
              val stop_pos : t -> Lexing.position
              val is_ghost : t -> bool
              val ghostify : t -> t
              val set_file_name : string -> t -> t
              val strictly_before : t -> t -> bool
              val make_absolute : t -> t
              val print : Format.formatter -> t -> unit
              val dump : Format.formatter -> t -> unit
              val to_string : t -> string
              exception Exc_located of t * exn
              val raise : t -> exn -> 'a
              val name : string ref
            end
          type t
          val to_string : t -> string
          val print : Format.formatter -> t -> unit
          val match_keyword : string -> t -> bool
          val extract_string : t -> string
          module Filter :
            sig
              type token_filter = (t, Loc.t) stream_filter
              type t
              val mk : (string -> bool) -> t
              val define_filter : t -> (token_filter -> token_filter) -> unit
              val filter : t -> token_filter
              val keyword_added : t -> string -> bool -> unit
              val keyword_removed : t -> string -> unit
            end
          module Error : Error
        end
      type gram
      type internal_entry
      type tree
      type token_pattern = (Token.t -> bool) * string
      type token_info
      type token_stream = (Token.t * token_info) Stream.t
      val token_location : token_info -> Loc.t
      type symbol =
          Smeta of string * symbol list * Action.t
        | Snterm of internal_entry
        | Snterml of internal_entry * string
        | Slist0 of symbol
        | Slist0sep of symbol * symbol
        | Slist1 of symbol
        | Slist1sep of symbol * symbol
        | Sopt of symbol
        | Stry of symbol
        | Sself
        | Snext
        | Stoken of token_pattern
        | Skeyword of string
        | Stree of tree
      type production_rule = symbol list * Action.t
      type single_extend_statment =
          string option * assoc option * production_rule list
      type extend_statment = position option * single_extend_statment list
      type delete_statment = symbol list
      type ('a, 'b, 'c) fold =
          internal_entry ->
          symbol list -> ('a Stream.t -> 'b) -> 'a Stream.t -> 'c
      type ('a, 'b, 'c) foldsep =
          internal_entry ->
          symbol list ->
          ('a Stream.t -> 'b) -> ('a Stream.t -> unit) -> 'a Stream.t -> 'c
      val mk : unit -> gram
      module Entry :
        sig
          type 'a t
          val mk : gram -> string -> 'a Camlp4.Sig.Grammar.Dynamic.Entry.t
          val of_parser :
            gram ->
            string ->
            (token_stream -> 'a) -> 'a Camlp4.Sig.Grammar.Dynamic.Entry.t
          val setup_parser :
            'a Camlp4.Sig.Grammar.Dynamic.Entry.t ->
            (token_stream -> 'a) -> unit
          val name : 'a Camlp4.Sig.Grammar.Dynamic.Entry.t -> string
          val print :
            Format.formatter -> 'a Camlp4.Sig.Grammar.Dynamic.Entry.t -> unit
          val dump :
            Format.formatter -> 'a Camlp4.Sig.Grammar.Dynamic.Entry.t -> unit
          val obj : 'a Camlp4.Sig.Grammar.Dynamic.Entry.t -> internal_entry
          val clear : 'a Camlp4.Sig.Grammar.Dynamic.Entry.t -> unit
        end
      val get_filter : gram -> Camlp4.Sig.Token.Filter.t
      type 'a not_filtered
      val extend :
        'a Camlp4.Sig.Grammar.Dynamic.Entry.t -> extend_statment -> unit
      val delete_rule :
        'a Camlp4.Sig.Grammar.Dynamic.Entry.t -> delete_statment -> unit
      val srules :
        'a Camlp4.Sig.Grammar.Dynamic.Entry.t ->
        (symbol list * Camlp4.Sig.Grammar.Action.t) list -> symbol
      val sfold0 : ('a -> 'b -> 'b) -> 'b -> ('c, 'a, 'b) fold
      val sfold1 : ('a -> 'b -> 'b) -> 'b -> ('c, 'a, 'b) fold
      val sfold0sep : ('a -> 'b -> 'b) -> 'b -> ('c, 'a, 'b) foldsep
      val lex :
        gram ->
        Camlp4.Sig.Loc.t ->
        char Stream.t ->
        (Camlp4.Sig.Token.t * Camlp4.Sig.Loc.t) Stream.t
        Camlp4.Sig.Grammar.Dynamic.not_filtered
      val lex_string :
        gram ->
        Camlp4.Sig.Loc.t ->
        string ->
        (Camlp4.Sig.Token.t * Camlp4.Sig.Loc.t) Stream.t
        Camlp4.Sig.Grammar.Dynamic.not_filtered
      val filter :
        gram ->
        (Camlp4.Sig.Token.t * Camlp4.Sig.Loc.t) Stream.t
        Camlp4.Sig.Grammar.Dynamic.not_filtered -> token_stream
      val parse :
        'a Camlp4.Sig.Grammar.Dynamic.Entry.t ->
        Camlp4.Sig.Loc.t -> char Stream.t -> 'a
      val parse_string :
        'a Camlp4.Sig.Grammar.Dynamic.Entry.t ->
        Camlp4.Sig.Loc.t -> string -> 'a
      val parse_tokens_before_filter :
        'a Camlp4.Sig.Grammar.Dynamic.Entry.t ->
        (Camlp4.Sig.Token.t * Camlp4.Sig.Loc.t) Stream.t
        Camlp4.Sig.Grammar.Dynamic.not_filtered -> 'a
      val parse_tokens_after_filter :
        'a Camlp4.Sig.Grammar.Dynamic.Entry.t -> token_stream -> 'a
    end
  module type Static =
    sig
      module Loc : Loc
      module Action : Action
      module Token :
        sig
          module Loc :
            sig
              type t = Loc.t
              val mk : string -> t
              val ghost : t
              val of_lexing_position : Lexing.position -> t
              val to_ocaml_location : t -> Camlp4_import.Location.t
              val of_ocaml_location : Camlp4_import.Location.t -> t
              val of_lexbuf : Lexing.lexbuf -> t
              val of_tuple :
                string * int * int * int * int * int * int * bool -> t
              val to_tuple :
                t -> string * int * int * int * int * int * int * bool
              val merge : t -> t -> t
              val join : t -> t
              val move : [ `both | `start | `stop ] -> int -> t -> t
              val shift : int -> t -> t
              val move_line : int -> t -> t
              val file_name : t -> string
              val start_line : t -> int
              val stop_line : t -> int
              val start_bol : t -> int
              val stop_bol : t -> int
              val start_off : t -> int
              val stop_off : t -> int
              val start_pos : t -> Lexing.position
              val stop_pos : t -> Lexing.position
              val is_ghost : t -> bool
              val ghostify : t -> t
              val set_file_name : string -> t -> t
              val strictly_before : t -> t -> bool
              val make_absolute : t -> t
              val print : Format.formatter -> t -> unit
              val dump : Format.formatter -> t -> unit
              val to_string : t -> string
              exception Exc_located of t * exn
              val raise : t -> exn -> 'a
              val name : string ref
            end
          type t
          val to_string : t -> string
          val print : Format.formatter -> t -> unit
          val match_keyword : string -> t -> bool
          val extract_string : t -> string
          module Filter :
            sig
              type token_filter = (t, Loc.t) stream_filter
              type t
              val mk : (string -> bool) -> t
              val define_filter : t -> (token_filter -> token_filter) -> unit
              val filter : t -> token_filter
              val keyword_added : t -> string -> bool -> unit
              val keyword_removed : t -> string -> unit
            end
          module Error : Error
        end
      type gram
      type internal_entry
      type tree
      type token_pattern = (Token.t -> bool) * string
      type token_info
      type token_stream = (Token.t * token_info) Stream.t
      val token_location : token_info -> Loc.t
      type symbol =
          Smeta of string * symbol list * Action.t
        | Snterm of internal_entry
        | Snterml of internal_entry * string
        | Slist0 of symbol
        | Slist0sep of symbol * symbol
        | Slist1 of symbol
        | Slist1sep of symbol * symbol
        | Sopt of symbol
        | Stry of symbol
        | Sself
        | Snext
        | Stoken of token_pattern
        | Skeyword of string
        | Stree of tree
      type production_rule = symbol list * Action.t
      type single_extend_statment =
          string option * assoc option * production_rule list
      type extend_statment = position option * single_extend_statment list
      type delete_statment = symbol list
      type ('a, 'b, 'c) fold =
          internal_entry ->
          symbol list -> ('a Stream.t -> 'b) -> 'a Stream.t -> 'c
      type ('a, 'b, 'c) foldsep =
          internal_entry ->
          symbol list ->
          ('a Stream.t -> 'b) -> ('a Stream.t -> unit) -> 'a Stream.t -> 'c
      module Entry :
        sig
          type 'a t
          val mk : string -> 'a Camlp4.Sig.Grammar.Static.Entry.t
          val of_parser :
            string ->
            (token_stream -> 'a) -> 'a Camlp4.Sig.Grammar.Static.Entry.t
          val setup_parser :
            'a Camlp4.Sig.Grammar.Static.Entry.t ->
            (token_stream -> 'a) -> unit
          val name : 'a Camlp4.Sig.Grammar.Static.Entry.t -> string
          val print :
            Format.formatter -> 'a Camlp4.Sig.Grammar.Static.Entry.t -> unit
          val dump :
            Format.formatter -> 'a Camlp4.Sig.Grammar.Static.Entry.t -> unit
          val obj : 'a Camlp4.Sig.Grammar.Static.Entry.t -> internal_entry
          val clear : 'a Camlp4.Sig.Grammar.Static.Entry.t -> unit
        end
      val get_filter : unit -> Camlp4.Sig.Token.Filter.t
      type 'a not_filtered
      val extend :
        'a Camlp4.Sig.Grammar.Static.Entry.t -> extend_statment -> unit
      val delete_rule :
        'a Camlp4.Sig.Grammar.Static.Entry.t -> delete_statment -> unit
      val srules :
        'a Camlp4.Sig.Grammar.Static.Entry.t ->
        (symbol list * Camlp4.Sig.Grammar.Action.t) list -> symbol
      val sfold0 : ('a -> 'b -> 'b) -> 'b -> ('c, 'a, 'b) fold
      val sfold1 : ('a -> 'b -> 'b) -> 'b -> ('c, 'a, 'b) fold
      val sfold0sep : ('a -> 'b -> 'b) -> 'b -> ('c, 'a, 'b) foldsep
      val lex :
        Camlp4.Sig.Loc.t ->
        char Stream.t ->
        (Camlp4.Sig.Token.t * Camlp4.Sig.Loc.t) Stream.t
        Camlp4.Sig.Grammar.Static.not_filtered
      val lex_string :
        Camlp4.Sig.Loc.t ->
        string ->
        (Camlp4.Sig.Token.t * Camlp4.Sig.Loc.t) Stream.t
        Camlp4.Sig.Grammar.Static.not_filtered
      val filter :
        (Camlp4.Sig.Token.t * Camlp4.Sig.Loc.t) Stream.t
        Camlp4.Sig.Grammar.Static.not_filtered -> token_stream
      val parse :
        'a Camlp4.Sig.Grammar.Static.Entry.t ->
        Camlp4.Sig.Loc.t -> char Stream.t -> 'a
      val parse_string :
        'a Camlp4.Sig.Grammar.Static.Entry.t ->
        Camlp4.Sig.Loc.t -> string -> 'a
      val parse_tokens_before_filter :
        'a Camlp4.Sig.Grammar.Static.Entry.t ->
        (Camlp4.Sig.Token.t * Camlp4.Sig.Loc.t) Stream.t
        Camlp4.Sig.Grammar.Static.not_filtered -> 'a
      val parse_tokens_after_filter :
        'a Camlp4.Sig.Grammar.Static.Entry.t -> token_stream -> 'a
    end
end