camlp5 8.01.00 · OCaml Package

val syntax_name : string Stdlib.ref

type status = Ploc.t option

type !'a ast_transducer_t = {

name : string;
parse : (char Stream.t -> 'a) option Stdlib.ref;
transform : ('a -> 'a) option Stdlib.ref;

}

val set_ast_parse : 'a ast_transducer_t -> (char Stream.t -> 'a) -> unit

val set_ast_transform : 'a ast_transducer_t -> ('a -> 'a) -> unit

val transduce : 'a ast_transducer_t -> char Stream.t -> 'a

val transduce_interf : 
  ((MLast.sig_item * MLast.loc) list * status) ast_transducer_t

val transduce_implem : 
  ((MLast.str_item * MLast.loc) list * status) ast_transducer_t

val transduce_top_phrase : MLast.str_item option ast_transducer_t

val transduce_use_file : (MLast.str_item list * bool) ast_transducer_t

val parse_interf : char Stream.t -> (MLast.sig_item * MLast.loc) list * status

val parse_implem : char Stream.t -> (MLast.str_item * MLast.loc) list * status

val parse_top_phrase : char Stream.t -> MLast.str_item option

val parse_use_file : char Stream.t -> MLast.str_item list * bool

val gram : Grammar.g

val attribute_body : MLast.attribute_body Grammar.Entry.e

val interf : ((MLast.sig_item * MLast.loc) list * status) Grammar.Entry.e

val implem : ((MLast.str_item * MLast.loc) list * status) Grammar.Entry.e

val top_phrase : MLast.str_item option Grammar.Entry.e

val use_file : (MLast.str_item list * bool) Grammar.Entry.e

val functor_parameter : MLast.functor_parameter Grammar.Entry.e

val module_type : MLast.module_type Grammar.Entry.e

val longident : MLast.longid Grammar.Entry.e

val longident_lident : MLast.longid_lident Grammar.Entry.e

val extended_longident : MLast.longid Grammar.Entry.e

val module_expr : MLast.module_expr Grammar.Entry.e

val signature : MLast.sig_item list MLast.v Grammar.Entry.e

val structure : MLast.str_item list MLast.v Grammar.Entry.e

val sig_item : MLast.sig_item Grammar.Entry.e

val str_item : MLast.str_item Grammar.Entry.e

val expr : MLast.expr Grammar.Entry.e

val patt : MLast.patt Grammar.Entry.e

val ipatt : MLast.patt Grammar.Entry.e

val ctyp : MLast.ctyp Grammar.Entry.e

val let_binding : (MLast.patt * MLast.expr * MLast.attributes) Grammar.Entry.e

val type_decl : MLast.type_decl Grammar.Entry.e

val type_extension : MLast.type_extension Grammar.Entry.e

val extension_constructor : MLast.extension_constructor Grammar.Entry.e

val match_case : 
  (MLast.patt * MLast.expr option MLast.v * MLast.expr) Grammar.Entry.e

val constructor_declaration : MLast.generic_constructor Grammar.Entry.e

val label_declaration : 
  (MLast.loc * string * bool * MLast.ctyp * MLast.attributes) Grammar.Entry.e

val with_constr : MLast.with_constr Grammar.Entry.e

val poly_variant : MLast.poly_variant Grammar.Entry.e

val class_sig_item : MLast.class_sig_item Grammar.Entry.e

val class_str_item : MLast.class_str_item Grammar.Entry.e

val class_expr : MLast.class_expr Grammar.Entry.e

val class_expr_simple : MLast.class_expr Grammar.Entry.e

val class_type : MLast.class_type Grammar.Entry.e

val alg_attribute : MLast.attribute Grammar.Entry.e

val alg_attributes : MLast.attributes Grammar.Entry.e

val ext_attributes : 
  ((Ploc.t * string) option * MLast.attributes_no_anti) Grammar.Entry.e

val input_file : string Stdlib.ref

val output_file : string option Stdlib.ref

val quotation_dump_file : string option Stdlib.ref

val quotation_location : unit -> Ploc.t

val version : string

val ocaml_version : string

val add_option : string -> Stdlib.Arg.spec -> string -> unit

val no_constructors_arity : bool Stdlib.ref

val string_of_loc : string -> int -> int -> int -> string

type err_ctx =

| Finding
| Expanding
| ParsingResult of Ploc.t * string

exception Qerror of string * string * err_ctx * exn

val expand_quotation : 
  Ploc.t ->
  (string -> 'b) ->
  int ->
  string ->
  string ->
  'b

val handle_expr_quotation : MLast.loc -> (string * string) -> MLast.expr

val handle_patt_quotation : MLast.loc -> (string * string) -> MLast.patt

val print_interf : 
  (((MLast.sig_item * MLast.loc) list * MLast.loc) -> unit) Stdlib.ref

val print_implem : 
  (((MLast.str_item * MLast.loc) list * MLast.loc) -> unit) Stdlib.ref

val pr_expr : MLast.expr Eprinter.t

val pr_patt : MLast.patt Eprinter.t

val pr_ctyp : MLast.ctyp Eprinter.t

val pr_str_item : MLast.str_item Eprinter.t

val pr_sig_item : MLast.sig_item Eprinter.t

val pr_longident : MLast.longid Eprinter.t

val pr_module_expr : MLast.module_expr Eprinter.t

val pr_module_type : MLast.module_type Eprinter.t

val pr_class_sig_item : MLast.class_sig_item Eprinter.t

val pr_class_str_item : MLast.class_str_item Eprinter.t

val pr_class_type : MLast.class_type Eprinter.t

val pr_class_expr : MLast.class_expr Eprinter.t

val pr_expr_fun_args : 
  (MLast.expr, MLast.patt list * MLast.expr) Extfun.t Stdlib.ref

val inter_phrases : string option Stdlib.ref

type directive_fun = MLast.expr option -> unit

val add_directive : string -> directive_fun -> unit

val find_directive : string -> directive_fun

val eq_expr : MLast.expr -> MLast.expr -> bool

val eq_patt : MLast.patt -> MLast.patt -> bool

val eq_ctyp : MLast.ctyp -> MLast.ctyp -> bool

val eq_str_item : MLast.str_item -> MLast.str_item -> bool

val eq_sig_item : MLast.sig_item -> MLast.sig_item -> bool

val eq_module_expr : MLast.module_expr -> MLast.module_expr -> bool

val eq_module_type : MLast.module_type -> MLast.module_type -> bool

val eq_class_sig_item : MLast.class_sig_item -> MLast.class_sig_item -> bool

val eq_class_str_item : MLast.class_str_item -> MLast.class_str_item -> bool

val eq_class_type : MLast.class_type -> MLast.class_type -> bool

val eq_class_expr : MLast.class_expr -> MLast.class_expr -> bool

val greek_ascii_equiv : string -> string

val strict_mode : bool Stdlib.ref

val unvala : 'a Ploc.vala -> 'a

val vala_map : ('a -> 'b) -> 'a Ploc.vala -> 'b Ploc.vala

val vala_it : ('a -> unit) -> 'a Ploc.vala -> unit

val vala_mapa : ('a -> 'b) -> (string -> 'b) -> 'a Ploc.vala -> 'b

val warning : (Ploc.t -> string -> unit) Stdlib.ref

val expr_eoi : MLast.expr Grammar.Entry.e

val patt_eoi : MLast.patt Grammar.Entry.e

val arg_spec_list : unit -> (string * Stdlib.Arg.spec * string) list

val report_error : exn -> unit

val sync : (char Stream.t -> unit) Stdlib.ref

val patt_reloc : (MLast.loc -> MLast.loc) -> int -> MLast.patt -> MLast.patt

val expr_reloc : (MLast.loc -> MLast.loc) -> int -> MLast.expr -> MLast.expr

val rename_id : (string -> string) Stdlib.ref

val flag_comments_in_phrases : bool Stdlib.ref

val flag_equilibrate_cases : bool Stdlib.ref

val flag_expand_letop_syntax : bool Stdlib.ref

package camlp5