sig
  module Loc :
    sig
      type t = Ast.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
  module Ast :
    sig
      type loc = Ast.loc
      type meta_bool = Ast.meta_bool
      type 'a meta_option = 'a Ast.meta_option
      type 'a meta_list = 'a Ast.meta_list
      type ctyp = Ast.ctyp
      type patt = Ast.patt
      type expr = Ast.expr
      type module_type = Ast.module_type
      type sig_item = Ast.sig_item
      type with_constr = Ast.with_constr
      type module_expr = Ast.module_expr
      type str_item = Ast.str_item
      type class_type = Ast.class_type
      type class_sig_item = Ast.class_sig_item
      type class_expr = Ast.class_expr
      type class_str_item = Ast.class_str_item
      type match_case = Ast.match_case
      type ident = Ast.ident
      type binding = Ast.binding
      type rec_binding = Ast.rec_binding
      type module_binding = Ast.module_binding
      type rec_flag = Ast.rec_flag
      type direction_flag = Ast.direction_flag
      type mutable_flag = Ast.mutable_flag
      type private_flag = Ast.private_flag
      type virtual_flag = Ast.virtual_flag
      type row_var_flag = Ast.row_var_flag
      type override_flag = Ast.override_flag
      val loc_of_ctyp : ctyp -> loc
      val loc_of_patt : patt -> loc
      val loc_of_expr : expr -> loc
      val loc_of_module_type : module_type -> loc
      val loc_of_module_expr : module_expr -> loc
      val loc_of_sig_item : sig_item -> loc
      val loc_of_str_item : str_item -> loc
      val loc_of_class_type : class_type -> loc
      val loc_of_class_sig_item : class_sig_item -> loc
      val loc_of_class_expr : class_expr -> loc
      val loc_of_class_str_item : class_str_item -> loc
      val loc_of_with_constr : with_constr -> loc
      val loc_of_binding : binding -> loc
      val loc_of_rec_binding : rec_binding -> loc
      val loc_of_module_binding : module_binding -> loc
      val loc_of_match_case : match_case -> loc
      val loc_of_ident : ident -> loc
      class map :
        object ('a)
          method binding : binding -> binding
          method class_expr : class_expr -> class_expr
          method class_sig_item : class_sig_item -> class_sig_item
          method class_str_item : class_str_item -> class_str_item
          method class_type : class_type -> class_type
          method ctyp : ctyp -> ctyp
          method direction_flag : direction_flag -> direction_flag
          method expr : expr -> expr
          method ident : ident -> ident
          method list : ('a -> 'b -> 'c) -> 'b list -> 'c list
          method loc : loc -> loc
          method match_case : match_case -> match_case
          method meta_bool : meta_bool -> meta_bool
          method meta_list : ('a -> 'd -> 'e) -> 'd meta_list -> 'e meta_list
          method meta_option :
            ('a -> 'f -> 'g) -> 'f meta_option -> 'g meta_option
          method module_binding : module_binding -> module_binding
          method module_expr : module_expr -> module_expr
          method module_type : module_type -> module_type
          method mutable_flag : mutable_flag -> mutable_flag
          method override_flag : override_flag -> override_flag
          method patt : patt -> patt
          method private_flag : private_flag -> private_flag
          method rec_binding : rec_binding -> rec_binding
          method rec_flag : rec_flag -> rec_flag
          method row_var_flag : row_var_flag -> row_var_flag
          method sig_item : sig_item -> sig_item
          method str_item : str_item -> str_item
          method string : string -> string
          method unknown : 'h -> 'h
          method virtual_flag : virtual_flag -> virtual_flag
          method with_constr : with_constr -> with_constr
        end
      class fold :
        object ('a)
          method binding : binding -> 'a
          method class_expr : class_expr -> 'a
          method class_sig_item : class_sig_item -> 'a
          method class_str_item : class_str_item -> 'a
          method class_type : class_type -> 'a
          method ctyp : ctyp -> 'a
          method direction_flag : direction_flag -> 'a
          method expr : expr -> 'a
          method ident : ident -> 'a
          method list : ('a -> 'b -> 'a) -> 'b list -> 'a
          method loc : loc -> 'a
          method match_case : match_case -> 'a
          method meta_bool : meta_bool -> 'a
          method meta_list : ('a -> 'c -> 'a) -> 'c meta_list -> 'a
          method meta_option : ('a -> 'd -> 'a) -> 'd meta_option -> 'a
          method module_binding : module_binding -> 'a
          method module_expr : module_expr -> 'a
          method module_type : module_type -> 'a
          method mutable_flag : mutable_flag -> 'a
          method override_flag : override_flag -> 'a
          method patt : patt -> 'a
          method private_flag : private_flag -> 'a
          method rec_binding : rec_binding -> 'a
          method rec_flag : rec_flag -> 'a
          method row_var_flag : row_var_flag -> 'a
          method sig_item : sig_item -> 'a
          method str_item : str_item -> 'a
          method string : string -> 'a
          method unknown : 'e -> 'a
          method virtual_flag : virtual_flag -> 'a
          method with_constr : with_constr -> 'a
        end
    end
  module Gram :
    sig
      module Loc :
        sig
          type t = Ast.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
      module Action :
        sig
          type t = Gram.Action.t
          val mk : 'a -> t
          val get : t -> 'a
          val getf : t -> 'a -> 'b
          val getf2 : t -> 'a -> 'b -> 'c
        end
      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 = Sig.camlp4_token
          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) Sig.stream_filter
              type t = Gram.Token.Filter.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 :
            sig
              type t = Gram.Token.Error.t
              exception E of t
              val to_string : t -> string
              val print : Format.formatter -> t -> unit
            end
        end
      type gram = Gram.gram
      type internal_entry = Gram.internal_entry
      type tree = Gram.tree
      type token_pattern = (Token.t -> bool) * string
      type token_info = Gram.token_info
      type token_stream = (Token.t * token_info) Stream.t
      val token_location : token_info -> Loc.t
      type symbol =
        Gram.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 * Sig.Grammar.assoc option * production_rule list
      type extend_statment =
          Sig.Grammar.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 = 'a Gram.Entry.t
          val mk : string -> 'a t
          val of_parser : string -> (token_stream -> 'a) -> 'a t
          val setup_parser : 'a t -> (token_stream -> 'a) -> unit
          val name : 'a t -> string
          val print : Format.formatter -> 'a t -> unit
          val dump : Format.formatter -> 'a t -> unit
          val obj : 'a t -> internal_entry
          val clear : 'a t -> unit
        end
      val get_filter : unit -> Token.Filter.t
      type 'a not_filtered = 'a Gram.not_filtered
      val extend : 'a Entry.t -> extend_statment -> unit
      val delete_rule : 'a Entry.t -> delete_statment -> unit
      val srules : 'a Entry.t -> (symbol list * 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 :
        Loc.t -> char Stream.t -> (Token.t * Loc.t) Stream.t not_filtered
      val lex_string :
        Loc.t -> string -> (Token.t * Loc.t) Stream.t not_filtered
      val filter : (Token.t * Loc.t) Stream.t not_filtered -> token_stream
      val parse : 'a Entry.t -> Loc.t -> char Stream.t -> 'a
      val parse_string : 'a Entry.t -> Loc.t -> string -> 'a
      val parse_tokens_before_filter :
        'a Entry.t -> (Token.t * Loc.t) Stream.t not_filtered -> 'a
      val parse_tokens_after_filter : 'a Entry.t -> token_stream -> 'a
    end
  val antiquot_expr :
    Camlp4.OCamlInitSyntax.Make.Ast.expr
    Camlp4.OCamlInitSyntax.Make.AntiquotSyntax.Gram.Entry.t
  val antiquot_patt :
    Camlp4.OCamlInitSyntax.Make.Ast.patt
    Camlp4.OCamlInitSyntax.Make.AntiquotSyntax.Gram.Entry.t
  val parse_expr :
    Camlp4.OCamlInitSyntax.Make.AntiquotSyntax.Gram.Loc.t ->
    string -> Camlp4.OCamlInitSyntax.Make.Ast.expr
  val parse_patt :
    Camlp4.OCamlInitSyntax.Make.AntiquotSyntax.Gram.Loc.t ->
    string -> Camlp4.OCamlInitSyntax.Make.Ast.patt
end