+ast2pt.cmi: $(OTOP)/parsing/location.cmi \

+ $(OTOP)/parsing/longident.cmi mLast.cmi \

+ast2pt.cmo: $(OTOP)/parsing/asttypes.cmi \

+ $(OTOP)/parsing/location.cmi $(OTOP)/parsing/longident.cmi \

+ mLast.cmi $(OTOP)/parsing/parsetree.cmi ast2pt.cmi

+ast2pt.cmx: $(OTOP)/parsing/asttypes.cmi \

+ $(OTOP)/parsing/location.cmi $(OTOP)/parsing/longident.cmi \

+ mLast.cmi $(OTOP)/parsing/parsetree.cmi ast2pt.cmi

+pcaml.cmo: ast2pt.cmi mLast.cmi quotation.cmi reloc.cmi spretty.cmi pcaml.cmi

+pcaml.cmx: ast2pt.cmx mLast.cmi quotation.cmx reloc.cmx spretty.cmx pcaml.cmi

+INTERFACES=-I $(OLIBDIR) Arg Array Buffer Callback Char Digest Filename Format Gc Genlex Hashtbl Lazy Lexing List Map Marshal Obj Oo Parsing Pervasives Printexc Printf Queue Random Set Sort Stack Stream String Sys Weak -I ../../boot Extfold Extfun Fstream Gramext Grammar Plexer Stdpp Token -I $(OTOP)/utils Config Warnings -I $(OTOP)/parsing Asttypes Location Longident Parsetree -I . Ast2pt MLast Pcaml Quotation Spretty

+CAMLP4_OBJS=../../boot/stdpp.cmo ../../boot/token.cmo ../../boot/plexer.cmo ../../boot/gramext.cmo ../../boot/grammar.cmo ../../boot/extfold.cmo ../../boot/extfun.cmo ../../boot/fstream.cmo $(OTOP)/utils/config.cmo quotation.cmo ast2pt.cmo spretty.cmo reloc.cmo pcaml.cmo argl.cmo crc.cmo

+CAMLP4_XOBJS=../lib/stdpp.cmx ../lib/token.cmx ../lib/plexer.cmx ../lib/gramext.cmx ../lib/grammar.cmx ../lib/extfold.cmx ../lib/extfun.cmx ../lib/fstream.cmx $(OTOP)/utils/config.cmx quotation.cmx ast2pt.cmx spretty.cmx reloc.cmx pcaml.cmx argl.cmx

+ Stream String Sys Weak -I :::boot: Extfold Extfun Fstream �

+ :::boot:gramext.cmo :::boot:grammar.cmo :::boot:extfold.cmo :::boot:extfun.cmo �

+type file_kind =

+ Intf

+ | Impl

+;;

+let mkpolytype t =

+ match t with

+ TyPol (_, _, _) -> t

+ | _ -> TyPol (MLast.loc_of_ctyp t, [], t)

+;;

+ | TyPol (loc, pl, t) -> mktyp loc (Ptyp_poly (pl, ctyp t))

+ | (lab, t) :: fl ->

+ mkfield loc (Pfield (lab, ctyp (mkpolytype t))) :: meth_list loc fl v

+let mktrecord (_, n, m, t) = n, mkmutable m, ctyp (mkpolytype t);;

+ long_id_of_string_list loc id, Pwith_module (module_expr_long_id m)

+ ExAcc (loc, x, ExLid (_, "val")) ->

+ mkexp loc

+ (Pexp_apply (mkexp loc (Pexp_ident (Lident "!")), ["", expr x]))

+ | ExAcc (loc, _, _) as e ->

+ ExAcc (loc, x, ExLid (_, "val")) ->

+ Pexp_apply

+ (mkexp loc (Pexp_ident (Lident ":=")), ["", expr x; "", expr v])

+ | ExAcc (loc, _, _) ->

+ | MtQuo (loc, _) -> error loc "abstract module type not allowed here"

+ let si =

+ match mt with

+ MtQuo (_, _) -> Pmodtype_abstract

+ | _ -> Pmodtype_manifest (module_type mt)

+ in

+ mksig loc (Psig_modtype (n, si)) :: l

+ Pctf_meth (s, mkprivate pf, ctyp (mkpolytype t), mkloc loc) :: l

+ | CgVir (loc, s, b, t) ->

+ Pctf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l

+ | CrMth (loc, s, b, e, t) ->

+ let t = option (fun t -> ctyp (mkpolytype t)) t in

+ let e = mkexp loc (Pexp_poly (expr e, t)) in

+ Pcf_meth (s, mkprivate b, e, mkloc loc) :: l

+ | CrVir (loc, s, b, t) ->

+ Pcf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l

+ | TyPol of loc * string list * ctyp

+and row_field =

+ RfTag of string * bool * ctyp list

+ | RfInh of ctyp

+ | MtQuo of loc * string

+ | WcMod of loc * string list * module_expr

+ | CrMth of loc * string * bool * expr * ctyp option

+(* Copyright 2002 Institut National de Recherche en Informatique et *)

+let version = "3.04+15";;

+

+let ov = Sys.ocaml_version in

+try

+ let oi = String.index ov ' ' in

+ let ov = String.sub ov 0 oi in

+ if String.sub version 0 (String.length ov) = ov then ()

+ else failwith "bad version"

+with

+ Not_found | Invalid_argument _ | Failure _ ->

+ Printf.eprintf "This OCaml and this Camlp4 are incompatible:\n";

+ Printf.eprintf "- OCaml version is %s\n" ov;

+ Printf.eprintf "- Camlp4 version is %s\n" version;

+ flush stderr;

+ failwith "bad versions";;

+ (fun _ -> raise (Match_failure ("pcaml.ml", 1506, 1512)));

+ Finding

+ | Expanding

+ | ParsingResult of (int * int) * string

+ | Locating

+ Format.print_char '\"';

+ Format.print_char '\"'

+ {pr_fun = (fun _ -> raise (Match_failure ("pcaml.ml", 12089, 12095)));

+ {pr_fun = (fun _ -> raise (Match_failure ("pcaml.ml", 12144, 12150)));

+ {pr_fun = (fun _ -> raise (Match_failure ("pcaml.ml", 12195, 12201)));

+ {pr_fun = (fun _ -> raise (Match_failure ("pcaml.ml", 12246, 12252)));

+ pr_levels = []}

+;;

+let pr_ctyp =

+ {pr_fun = (fun _ -> raise (Match_failure ("pcaml.ml", 12297, 12303)));

+ pr_levels = []}

+;;

+let pr_class_str_item =

+ {pr_fun = (fun _ -> raise (Match_failure ("pcaml.ml", 12358, 12364)));

+pr_ctyp.pr_fun <- pr_fun "ctyp" pr_ctyp;;

+pr_class_str_item.pr_fun <- pr_fun "class_str_item" pr_class_str_item;;

+ Format.print_newline "<< " " " 78 (fun _ _ -> "", 0, 0, 0) 0

+(** Language grammar, entries and printers.

+ Hold variables to be set by language syntax extensions. Some of them

+(** {6 Parsers} *)

+ (** Some grammar and entries of the language, set by [pa_o.cmo] and

+ (** The file currently being parsed. *)

+ (** The output file, stdout if None (default) *)

+ (** Prints an error message, using the module [Format]. *)

+ (** [quotation_dump_file] optionally tells the compiler to dump the

+ (** The current version of Camlp4. *)

+ (** Add an option to the command line options. *)

+ (** [True]: dont generate constructor arity. *)

+ (** [True]: dont generate assertion checks. *)

+(** Allow user to catch exceptions in quotations *)

+ Finding

+ | Expanding

+ | ParsingResult of (int * int) * string

+ | Locating

+(** {6 Printers} *)

+ (** Some printers, set by [pr_dump.cmo], [pr_o.cmo] and [pr_r.cmo]. *)

+val pr_ctyp : MLast.ctyp printer_t;;

+val pr_class_str_item : MLast.class_str_item printer_t;;

+(**/**)

+

+(** Quotation operations. *)

+

+(** The type for quotation expanders kind:

+- [ExStr exp] for an expander [exp] returning a string which

+- [ExAst (expr_exp, patt_exp)] for expanders returning directly

+ (** [add name exp] adds the quotation [name] associated with the

+ (** [find name] returns the expander of the given quotation name. *)

+ (** [default] holds the default quotation name. *)

+ (** function translating quotation names; default = identity *)

+ | TyPol (loc, x1, x2) -> TyPol (floc loc, x1, self x2)

+ | MtQuo (loc, x1) -> MtQuo (floc loc, x1)

+ | WcMod (loc, x1, x2) -> WcMod (floc loc, x1, module_expr floc sh x2)

+ | CrMth (loc, x1, x2, x3, x4) ->

+ CrMth

+ (floc loc, x1, x2, expr floc sh x3, option_map (ctyp floc sh) x4)

+(* Copyright 2002 Institut National de Recherche en Informatique et *)

+type glue =

+ LO

+ | RO

+ | LR

+ | NO

+;;

+ | LI of (string * int * int) * prettyL

+type getcomm = int -> int -> string * int * int * int;;

+let last_ep = ref 0;;

+let getcomm = ref (fun _ _ -> "", 0, 0, 0);;

+let lazy_tab = ref (-1);;

+let flush_tab () =

+ if !lazy_tab >= 0 then

+ begin

+ !print_newline_fun ();

+ !print_string_fun !prompt;

+ for i = 1 to !lazy_tab do !print_char_fun !sp done;

+ lazy_tab := -1

+ end

+;;

+let print_newline_and_tab tab = lazy_tab := tab;;

+let print_char c = flush_tab (); !print_char_fun c;;

+let print_string s = flush_tab (); !print_string_fun s;;

+let rec print_spaces nsp = for i = 1 to nsp do print_char !sp done;;

+

+let end_with_tab s =

+ let rec loop i =

+ if i >= 0 then if s.[i] = ' ' then loop (i - 1) else s.[i] = '\n'

+ else false

+ in

+ loop (String.length s - 1)

+;;

+

+let print_comment tab s nl_bef tab_bef empty_stmt =

+ if s = "" then ()

+ else

+ let (tab_aft, i_bef_tab) =

+ let rec loop tab_aft i =

+ if i >= 0 && s.[i] = ' ' then loop (tab_aft + 1) (i - 1)

+ else tab_aft, i

+ in

+ loop 0 (String.length s - 1)

+ in

+ let tab_bef = if nl_bef > 0 then tab_bef else tab in

+ let len = if empty_stmt then i_bef_tab else String.length s in

+ let rec loop i =

+ if i = len then ()

+ else

+ begin

+ !print_char_fun s.[i];

+ let i =

+ if s.[i] = '\n' && (i + 1 = len || s.[i + 1] <> '\n') then

+ let delta_ind =

+ if i = i_bef_tab then tab - tab_aft else tab - tab_bef

+ in

+ if delta_ind >= 0 then

+ begin

+ for i = 1 to delta_ind do !print_char_fun ' ' done; i + 1

+ end

+ else

+ let rec loop cnt i =

+ if cnt = 0 then i

+ else if i = len then i

+ else if s.[i] = ' ' then loop (cnt + 1) (i + 1)

+ else i

+ in

+ loop delta_ind (i + 1)

+ else i + 1

+ in

+ loop i

+ end

+ in

+ loop 0

+let rec has_comment =

+ function

+ LI ((comm, nl_bef, tab_bef), x) :: pl ->

+ comm <> "" || has_comment (x :: pl)

+ | (HL x | BL x | PL x | QL x | VL x | BE x | BV x) :: pl ->

+ has_comment x || has_comment pl

+ | SL (_, _, _) :: pl -> has_comment pl

+ | [] -> false

+;;

+

+let rec hprint_pretty tab pos spc =

+ | HL x -> hprint_box tab pos spc x

+ | BL x -> hprint_box tab pos spc x

+ | PL x -> hprint_box tab pos spc x

+ | QL x -> hprint_box tab pos spc x

+ | VL [x] -> hprint_pretty tab pos spc x

+ | VL x -> hprint_box tab pos spc x

+ | BE x -> hprint_box tab pos spc x

+ | LI ((comm, nl_bef, tab_bef), x) ->

+ if !lazy_tab >= 0 then

+ begin

+ for i = 2 to nl_bef do !print_char_fun '\n' done; flush_tab ()

+ end;

+ print_comment tab comm nl_bef tab_bef false;

+ hprint_pretty tab pos spc x

+and hprint_box tab pos spc =

+ let (pos, spc) = hprint_pretty tab pos spc p in

+ hprint_box tab pos spc pl

+ | LI ((comm, nl_bef, tab_bef), x) ->

+ if !lazy_tab >= 0 then

+ begin

+ for i = 2 to nl_bef do !print_char_fun '\n' done;

+ if comm <> "" && nl_bef = 0 then

+ for i = 1 to tab_bef do !print_char_fun ' ' done

+ else if comm = "" && x = BL [] then lazy_tab := -1

+ else flush_tab ()

+ end;

+ print_comment tab comm nl_bef tab_bef (x = BL []);

+ if comm <> "" && nl_bef = 0 then

+ if end_with_tab comm then lazy_tab := -1 else flush_tab ();

+ print_pretty tab pos spc x

+ | _ -> false

+ then

+ if ov || has_comment pl then print_vertic tab pos spc pl

+ else hprint_box tab pos spc pl

+ | _ -> false

+ then

+ print_newline_and_tab (tab + !dt); print_vertic_rest (tab + !dt) pl

+ | _ -> false

+ then

+ else begin print_newline_and_tab tab; print_vertic_rest tab pl end

+ if has_comment pl then print_vertic tab pos spc pl

+ else if ov then print_parag tab pos spc pl

+ else hprint_box tab pos spc pl

+ | _ -> false

+ then

+ print_newline_and_tab (tab + !dt);

+ begin print_newline_and_tab tab; tab, 0 end

+ | _ -> false

+ then

+ begin print_newline_and_tab tab; tab, 0 end

+ if has_comment pl then print_vertic tab pos spc pl

+ else if ov then print_sparag tab pos spc pl

+ else hprint_box tab pos spc pl

+ | _ -> false

+ then

+ begin print_newline_and_tab tab; tab, 0 end

+ | _ -> false

+ then

+ if ov || has_comment pl then print_beg_end tab pos spc pl

+ else hprint_box tab pos spc pl

+ | _ -> false

+ then

+ print_newline_and_tab (tab + !dt);

+ | _ -> false

+ then

+ else begin print_newline_and_tab tab; print_beg_end_rest tab tab pl end

+ | LocInfo ((bp, ep), x) ->

+ let (comm, nl_bef, tab_bef, cnt) =

+ let len = bp - !last_ep in

+ if len > 0 then !getcomm !last_ep len else "", 0, 0, 0

+ in

+ last_ep := !last_ep + cnt;

+ let v = conv x in

+ last_ep := max ep !last_ep; LI ((comm, nl_bef, tab_bef), v)

+ Some p -> Stream.junk strm__; let x = conv p in x :: conv_stream strm__

+let print_pretty pr_ch pr_str pr_nl pr pr2 m lf bp p =

+ getcomm := lf;

+ last_ep := bp;

+type glue =

+ LO

+ | RO

+ | LR

+ | NO

+;;

+type getcomm = int -> int -> string * int * int * int;;

+ int -> getcomm -> int -> pretty -> unit;;

+extfold.cmi: gramext.cmi

+extfold.cmo: gramext.cmi grammar.cmi extfold.cmi

+extfold.cmx: gramext.cmx grammar.cmx extfold.cmi

+OBJS=stdpp.cmo token.cmo plexer.cmo gramext.cmo grammar.cmo extfold.cmo extfun.cmo fstream.cmo

+OBJS = stdpp.cmo token.cmo plexer.cmo gramext.cmo grammar.cmo extfold.cmo extfun.cmo fstream.cmo

+INTF = stdpp.cmi token.cmi plexer.cmi gramext.cmi grammar.cmi extfold.cmi extfun.cmi fstream.cmi

+(* camlp4r *)

+(* This file has been generated by program: do not edit! *)

+

+type ('te, 'a, 'b) t =

+ 'te Gramext.g_entry -> 'te Gramext.g_symbol list -> ('te Stream.t -> 'a) ->

+ 'te Stream.t -> 'b

+;;

+

+type ('te, 'a, 'b) tsep =

+ 'te Gramext.g_entry -> 'te Gramext.g_symbol list -> ('te Stream.t -> 'a) ->

+ ('te Stream.t -> unit) -> 'te Stream.t -> 'b

+;;

+

+let gen_fold0 final f e entry symbl psymb =

+ let rec fold accu (strm__ : _ Stream.t) =

+ match

+ try Some (psymb strm__) with

+ Stream.Failure -> None

+ with

+ Some a -> fold (f a accu) strm__

+ | _ -> accu

+ in

+ fun (strm__ : _ Stream.t) -> let a = fold e strm__ in final a

+;;

+

+let gen_fold1 final f e entry symbl psymb =

+ let rec fold accu (strm__ : _ Stream.t) =

+ match

+ try Some (psymb strm__) with

+ Stream.Failure -> None

+ with

+ Some a -> fold (f a accu) strm__

+ | _ -> accu

+ in

+ fun (strm__ : _ Stream.t) ->

+ let a = psymb strm__ in

+ let a =

+ try fold (f a e) strm__ with

+ Stream.Failure -> raise (Stream.Error "")

+ in

+ final a

+;;

+

+let gen_fold0sep final f e entry symbl psymb psep =

+ let failed =

+ function

+ [symb; sep] -> Grammar.symb_failed_txt entry sep symb

+ | _ -> "failed"

+ in

+ let rec kont accu (strm__ : _ Stream.t) =

+ match

+ try Some (psep strm__) with

+ Stream.Failure -> None

+ with

+ Some v ->

+ let a =

+ try psymb strm__ with

+ Stream.Failure -> raise (Stream.Error (failed symbl))

+ in

+ kont (f a accu) strm__

+ | _ -> accu

+ in

+ fun (strm__ : _ Stream.t) ->

+ match

+ try Some (psymb strm__) with

+ Stream.Failure -> None

+ with

+ Some a -> final (kont (f a e) strm__)

+ | _ -> e

+;;

+

+let gen_fold1sep final f e entry symbl psymb psep =

+ let failed =

+ function

+ [symb; sep] -> Grammar.symb_failed_txt entry sep symb

+ | _ -> "failed"

+ in

+ let parse_top =

+ function

+ [symb; _] -> Grammar.parse_top_symb entry symb

+ | _ -> raise Stream.Failure

+ in

+ let rec kont accu (strm__ : _ Stream.t) =

+ match

+ try Some (psep strm__) with

+ Stream.Failure -> None

+ with

+ Some v ->

+ let a =

+ try

+ try psymb strm__ with

+ Stream.Failure ->

+ let a =

+ try parse_top symbl strm__ with

+ Stream.Failure -> raise (Stream.Error (failed symbl))

+ in

+ Obj.magic a

+ with

+ Stream.Failure -> raise (Stream.Error "")

+ in

+ kont (f a accu) strm__

+ | _ -> accu

+ in

+ fun (strm__ : _ Stream.t) ->

+ let a = psymb strm__ in final (kont (f a e) strm__)

+;;

+

+let sfold0 f e = gen_fold0 (fun x -> x) f e;;

+let sfold1 f e = gen_fold1 (fun x -> x) f e;;

+let sfold0sep f e = gen_fold0sep (fun x -> x) f e;;

+let sfold1sep f e = gen_fold1sep (fun x -> x) f e;;

+

+let cons x y = x :: y;;

+let nil = [];;

+

+let slist0 entry = gen_fold0 List.rev cons nil entry;;

+let slist1 entry = gen_fold1 List.rev cons nil entry;;

+let slist0sep entry = gen_fold0sep List.rev cons nil entry;;

+let slist1sep entry = gen_fold1sep List.rev cons nil entry;;

+

+let sopt entry symbl psymb (strm__ : _ Stream.t) =

+ try Some (psymb strm__) with

+ Stream.Failure -> None

+;;

+(* camlp4r *)

+(* This file has been generated by program: do not edit! *)

+

+type ('te, 'a, 'b) t =

+ 'te Gramext.g_entry -> 'te Gramext.g_symbol list -> ('te Stream.t -> 'a) ->

+ 'te Stream.t -> 'b

+;;

+

+type ('te, 'a, 'b) tsep =

+ 'te Gramext.g_entry -> 'te Gramext.g_symbol list -> ('te Stream.t -> 'a) ->

+ ('te Stream.t -> unit) -> 'te Stream.t -> 'b

+;;

+

+val sfold0 : ('a -> 'b -> 'b) -> 'b -> (_, 'a, 'b) t;;

+val sfold1 : ('a -> 'b -> 'b) -> 'b -> (_, 'a, 'b) t;;

+val sfold0sep : ('a -> 'b -> 'b) -> 'b -> (_, 'a, 'b) tsep;;

+val sfold1sep : ('a -> 'b -> 'b) -> 'b -> (_, 'a, 'b) tsep;;

+

+val slist0 : (_, 'a, 'a list) t;;

+val slist1 : (_, 'a, 'a list) t;;

+val slist0sep : (_, 'a, 'a list) tsep;;

+val slist1sep : (_, 'a, 'a list) tsep;;

+

+val sopt : (_, 'a, 'a option) t;;

+(** Extensible functions.

+ This module implements pattern matching extensible functions.

+

+ [extfun e with [ pattern_matching ]] *)

+ (** The type of the extensible functions of type ['a -> 'b] *)

+ (** Empty extensible function *)

+ (** Apply an extensible function *)

+ (** Match failure while applying an extensible function *)

+ (** Print patterns in the order they are recorded *)

+(**/**)

+and 'a data =

+ Nil

+ | Cons of 'a * 'a t

+ | App of 'a t * 'a t

+ Dlevels of 'te g_level list

+ | Dparser of ('te Stream.t -> Obj.t)

+and g_assoc =

+ NonA

+ | RightA

+ | LeftA

+ Smeta of string * 'te g_symbol list * Obj.t

+ | Snterm of 'te g_entry

+ Node of 'te g_node

+ | LocAct of g_action * g_action list

+ | DeadEnd

+ First

+ | Last

+ | Before of string

+ | After of string

+ | Level of string

+ | Smeta (_, _, _) | Slist1 _ | Slist1sep (_, _) | Snterm _ |

+ Snterml (_, _) | Snext | Sself | Stoken _ ->

+ false

+ | DeadEnd -> false

+ | LocAct (_, _) | DeadEnd -> None

+ | None -> ()

+ | Smeta (_, sl, _) -> List.iter (check_gram entry) sl

+ | Snext | Sself | Stoken _ -> ()

+ | LocAct (_, _) | DeadEnd -> ()

+ Smeta (_, sl, _) -> List.iter insert sl

+ | Slist0 s -> insert s

+ | Snterm _ | Snterml (_, _) | Snext | Sself -> ()

+ | LocAct (_, _) | DeadEnd -> ()

+ | Smeta (_, sl, _) -> List.iter (decr_keyw_use gram) sl

+ | Sself | Snext | Snterm _ | Snterml (_, _) -> ()

+ Dlevels of 'te g_level list

+ | Dparser of ('te Stream.t -> Obj.t)

+and g_assoc =

+ NonA

+ | RightA

+ | LeftA

+ Smeta of string * 'te g_symbol list * Obj.t

+ | Snterm of 'te g_entry

+ Node of 'te g_node

+ | LocAct of g_action * g_action list

+ | DeadEnd

+ First

+ | Last

+ | Before of string

+ | After of string

+ | Level of string

+ Smeta (n, sl, _) -> print_meta ppf n sl

+ | Slist0 s -> fprintf ppf "LIST0 %a" print_symbol1 s

+ | Snterm _ | Snext | Sself | Stoken _ | Stree _ as s -> print_symbol1 ppf s

+and print_meta ppf n sl =

+ let rec loop i =

+ function

+ [] -> ()

+ | s :: sl ->

+ let j =

+ try String.index_from n i ' ' with

+ Not_found -> String.length n

+ in

+ fprintf ppf "%s %a" (String.sub n i (j - i)) print_symbol1 s;

+ if sl = [] then ()

+ else

+ begin fprintf ppf " "; loop (min (j + 1) (String.length n)) sl end

+ in

+ loop 0 sl

+ | Smeta (_, _, _) | Snterml (_, _) | Slist0 _ | Slist0sep (_, _) |

+ Slist1 _ | Slist1sep (_, _) | Sopt _ | Stoken _ as s ->

+ fprintf ppf "(%a)" print_symbol s

+ | None -> ()

+ | Node _ -> txt ^ " or " ^ name_of_tree_failed entry bro

+ | LocAct (_, _) | DeadEnd -> None

+ | Dparser _ -> tree

+ | LocAct (_, _) | DeadEnd -> raise Stream.Failure

+let do_recover

+ parser_of_tree entry nlevn alevn bp a s son (strm__ : _ Stream.t) =

+let token_count = ref 0;;

+

+ token_count := Stream.count strm + n;

+ | None -> raise Stream.Failure

+ Smeta (_, symbl, act) ->

+ let act = Obj.magic act entry symbl in

+ Obj.magic

+ (List.fold_left

+ (fun act symb -> Obj.magic act (parser_of_symbol entry nlevn symb))

+ act symbl)

+ | Slist0 s ->

+ try parse_top_symb entry symb strm__ with

+and parse_top_symb entry symb =

+ parser_of_symbol entry 0 (top_symb entry symb)

+let symb_failed_txt e s1 s2 = symb_failed e 0 s1 s2;;

+

+ let restore =

+ let old_floc = !floc in

+ let old_tc = !token_count in

+ fun () -> floc := old_floc; token_count := old_tc

+ in

+ let get_loc () =

+ try

+ let cnt = Stream.count ts in

+ let loc = fun_loc cnt in

+ if !token_count - 1 <= cnt then loc

+ else fst loc, snd (fun_loc (!token_count - 1))

+ with

+ _ -> Stream.count cs, Stream.count cs + 1

+ in

+ token_count := 0;

+ let loc = get_loc () in

+ let loc = get_loc () in restore (); raise_with_loc loc exc

+ | Dparser _ -> ()

+ | Smeta (_, sl, _) -> find_symbol_list sl

+ | Sself | Snext | Stoken _ -> None

+ and find_symbol_list =

+ function

+ s :: sl ->

+ begin match find_symbol s with

+ None -> find_symbol_list sl

+ | x -> x

+ end

+ | [] -> None

+ | LocAct (_, _) | DeadEnd -> None

+ end)

+ (L)

+ GGMake (struct let reinit_gram = reinit_gram;; end)

+ (struct type te = Token.t;; let lexer = glexer_of_lexer L.lexer;; end)

+(** Extensible grammars.

+ This module implements the Camlp4 extensible grammars system.

+ Grammars entries can be extended using the [EXTEND] statement,

+ added by loading the Camlp4 [pa_extend.cmo] file. *)

+ (** The type for grammars, holding entries. *)

+ (** Create a new grammar, without keywords, using the lexer given

+ (** Given a grammar and a token pattern constructor, returns the list of

+ (** 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_token e] returns the token 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.print e] displays the entry [e] using [Format].

+- [Entry.find e s] finds the entry named [s] in [e]'s rules.

+- [Entry.obj e] converts an entry into a [Gramext.g_entry] allowing

+- to see what it holds ([Gramext] is visible, but not documented). *)

+ (** Return the grammar associated with an entry. *)

+(** {6 Clearing grammars and entries} *)

+ (** Module for clearing grammars and entries. To be manipulated with

+- [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:

+ normal OCaml typing. *)

+ (** The input signature for the functor [Grammar.GMake]: [te] is the

+ type of the tokens. *)

+ val extend :

+ (** Signature type of the functor [Grammar.GMake]. The types and

+- Grammars are not values. Functions holding a grammar as parameter

+ do not have this parameter yet.

+- The type [parsable] is used in function [parse] instead of

+ the char stream, avoiding the possible loss of tokens.

+- The type of tokens (expressions and patterns) can be any

+ type (instead of (string * string)); the module parameter

+ must specify a way to show them as (string * string) *)

+(** {6 Miscellaneous} *)

+

+val error_verbose : bool ref;;

+ (** Flag for displaying more information in case of parsing error;

+ default = [False] *)

+

+val warning_verbose : bool ref;;

+ (** Flag for displaying warnings while extension; default = [True] *)

+

+val strict_parsing : bool ref;;

+ (** Flag to apply strict parsing, without trying to recover errors;

+ default = [False] *)

+

+ (** General printer for all kinds of entries (obj entries) *)

+(**/**)

+(*** deprecated since version 3.05; use rather the functor GMake *)

+(*** deprecated since version 3.05; use rather the function gcreate *)

+

+val parse_top_symb :

+ 'te Gramext.g_entry -> 'te Gramext.g_symbol -> 'te Stream.t -> Obj.t;;

+val symb_failed_txt :

+ 'te Gramext.g_entry -> 'te Gramext.g_symbol -> 'te Gramext.g_symbol ->

+ string;;

+ let tok = "CHAR", get_buff (char bp 0 s) in

+ | Some '\"' ->

+ let tok = "STRING", get_buff (string bp 0 strm__) in

+ Some '\"' -> Stream.junk strm__; len

+ let s = strm__ in if len = 0 then char bp (store len '\'') s else len

+ | Some '\"' ->

+ Stream.junk strm__;

+ let _ =

+ try string bp 0 strm__ with

+ Stream.Failure -> raise (Stream.Error "")

+ in

+ comment bp strm__

+ | Some '\'' -> Stream.junk strm__; quote_in_comment bp strm__

+ and quote_in_comment bp (strm__ : _ Stream.t) =

+ match Stream.peek strm__ with

+ Some '\'' -> Stream.junk strm__; comment bp strm__

+ | Some '\\' -> Stream.junk strm__; quote_antislash_in_comment bp 0 strm__

+ | Some _ -> Stream.junk strm__; quote_any_in_comment bp strm__

+ | _ -> comment bp strm__

+ and quote_any_in_comment bp (strm__ : _ Stream.t) =

+ match Stream.peek strm__ with

+ Some '\'' -> Stream.junk strm__; comment bp strm__

+ | _ -> comment bp strm__

+ and quote_antislash_in_comment bp len (strm__ : _ Stream.t) =

+ match Stream.peek strm__ with

+ Some '\'' -> Stream.junk strm__; comment bp strm__

+ | Some ('\\' | '\"' | 'n' | 't' | 'b' | 'r') ->

+ Stream.junk strm__; quote_any_in_comment bp strm__

+ | Some ('0'..'9') ->

+ Stream.junk strm__; quote_antislash_digit_in_comment bp strm__

+ | _ -> comment bp strm__

+ and quote_antislash_digit_in_comment bp (strm__ : _ Stream.t) =

+ match Stream.peek strm__ with

+ Some ('0'..'9') ->

+ Stream.junk strm__; quote_antislash_digit2_in_comment bp strm__

+ | _ -> comment bp strm__

+ and quote_antislash_digit2_in_comment bp (strm__ : _ Stream.t) =

+ match Stream.peek strm__ with

+ Some ('0'..'9') -> Stream.junk strm__; quote_any_in_comment bp strm__

+ | _ -> comment bp strm__

+ Some '\"' ->

+(** A lexical analyzer. *)

+ (** Some lexer provided. See the module [Token]. The tokens returned

+ Warning: the string associated with the constructor [STRING] is

+ the string found in the source without any interpretation. In

+ particular, the backslashes are not interpreted. For example, if

+ the input is ["\n"] the string is *not* a string with one

+ element containing the character "return", but a string of two

+ elements: the backslash and the character ["n"]. To interpret

+ a string use the function [Token.eval_string]. Same thing for

+ the constructor [CHAR]: to get the character, don't get the

+ first character of the string, but use the function

+ [Token.eval_char].

+

+ (** When True (default), the next call to [Plexer.make ()] returns a

+ (** When True, all lexers built by [Plexer.make ()] do not lex the

+(**/**)

+(* deprecated since version 3.05; use rather function gmake *)

+(** Standard definitions. *)

+ (** [Exc_located loc e] is an encapsulation of the exception [e] with

+ (** [raise_with_loc loc e], if [e] is already the exception [Exc_located],

+ (** [line_of_loc fname loc] reads the file [fname] up to the

+ (** Name of the location variable used in grammars and in the predefined

+ | '\"' -> '\"', i + 1

+ | '\'' -> '\'', i + 1

+ else if s.[i] = '\"' then store len '\"', i + 1

+(** Lexers for Camlp4 grammars.

+ This module defines the Camlp4 lexer type to be used in extensible

+ (** Token patterns come from the EXTEND statement.

+- The way tokens patterns are interpreted to parse tokens is

+ done by the lexer, function [tok_match] below. *)

+ (** An lexing error exception to be used by lexers. *)

+(** {6 Lexer type} *)

+ (** The type for a function associating a number of a token in a stream

+ (** The type for a lexer function. The character stream is the input

+ (** The type for a lexer used by Camlp4 grammars.

+ (** A simple [tok_text] function for lexers *)

+val default_match : pattern -> string * string -> string;;

+ (** A simple [tok_match] function for lexers, appling to token type

+ [(string * string)] *)

+(** {6 Lexers from char stream parsers or ocamllex function}

+ The functions below create lexer functions either from a [char stream]

+ {[

+ { Token.tok_func = f;

+ Token.tok_using = (fun _ -> ());

+ Token.tok_removing = (fun _ -> ());

+ Token.tok_match = Token.default_match;

+ Token.tok_text = Token.lexer_text }

+ ]}

+ (** A lexer function from a lexer written as a char stream parser

+ (** A lexer function from a lexer created by [ocamllex] *)

+ (** General function *)

+(** {6 Useful functions} *)

+ (** Convert a char or a string token, where the backslashes had not

+(**/**)

+(* deprecated since version 3.05; use rather type glexer *)

+type t = string * string;;

+pa_extend_m.cmo: pa_extend.cmo

+pa_extend_m.cmx: pa_extend.cmx

+pr_dump.cmo: ../camlp4/ast2pt.cmi ../camlp4/pcaml.cmi \

+ $(OTOP)/utils/config.cmo

+pr_dump.cmx: ../camlp4/ast2pt.cmx ../camlp4/pcaml.cmx \

+ $(OTOP)/utils/config.cmx

+ cp $(COUT) pa_extend.cmi ../../boot/.

+ cp pa_ifdef.cmi pa_extend.cmi $(LIBDIR)/camlp4/.

+ duplicate -y {OUT} pa_extend.cmi :::boot:

+ | STapp of loc * styp * styp

+ | STself of loc * string

+ | STtyp of MLast.ctyp

+ TXmeta of loc * string * 'e text list * 'e * styp

+ | TXlist of loc * bool * 'e text * 'e text option

+and ('e, 'p) symbol = { used : string list; text : 'e text; styp : styp }

+type used =

+ Unused

+ | UsedScanned

+ | UsedNotScanned

+;;

+ let rll = Hashtbl.find_all ht n in

+ | STapp (loc, t1, t2) ->

+ MLast.TyApp (loc, make_ctyp t1 tvar, make_ctyp t2 tvar)

+ | STself (loc, x) ->

+ | STtyp t -> t

+ TXmeta (loc, n, tl, e, t) ->

+ let el =

+ List.fold_right

+ (fun t el ->

+ MLast.ExApp

+ (loc,

+ MLast.ExApp

+ (loc, MLast.ExUid (loc, "::"), make_expr gmod "" t),

+ el))

+ tl (MLast.ExUid (loc, "[]"))

+ in

+ MLast.ExApp

+ (loc,

+ MLast.ExApp

+ (loc,

+ MLast.ExApp

+ (loc,

+ MLast.ExAcc

+ (loc, MLast.ExUid (loc, "Gramext"),

+ MLast.ExUid (loc, "Smeta")),

+ MLast.ExStr (loc, n)),

+ el),

+ MLast.ExApp

+ (loc,

+ MLast.ExAcc

+ (loc, MLast.ExUid (loc, "Obj"), MLast.ExLid (loc, "repr")),

+ MLast.ExTyc (loc, e, make_ctyp t tvar)))

+ | TXlist (loc, min, t, ts) ->

+let sslist loc min sep s =

+ (STapp (loc, STlid (loc, "list"), s.styp))]

+ let used =

+ match sep with

+ Some symb -> symb.used @ s.used

+ | None -> s.used

+ in

+ let used = "a_list" :: used in

+ let text = TXrules (loc, srules loc "a_list" rl "") in

+ let styp = STquo (loc, "a_list") in {used = used; text = text; styp = styp}

+ (STapp (loc, STlid (loc, "option"), s.styp))]

+ let used = "a_opt" :: s.used in

+ let text = TXrules (loc, srules loc "a_opt" rl "") in

+ let styp = STquo (loc, "a_opt") in {used = used; text = text; styp = styp}

+ let symb = {used = [i]; text = text; styp = styp} in

+ (if !quotify then ssopt loc s

+ else

+ let styp = STapp (loc, STlid (loc, "option"), s.styp) in

+ let text = TXopt (loc, s.text) in

+ {used = s.used; text = text; styp = styp} :

+ (if !quotify then sslist loc true sep s

+ else

+ let used =

+ match sep with

+ Some symb -> symb.used @ s.used

+ | None -> s.used

+ in

+ let styp = STapp (loc, STlid (loc, "list"), s.styp) in

+ let text = slist loc true sep s in

+ {used = used; text = text; styp = styp} :

+ (if !quotify then sslist loc false sep s

+ else

+ let used =

+ match sep with

+ Some symb -> symb.used @ s.used

+ | None -> s.used

+ in

+ let styp = STapp (loc, STlid (loc, "list"), s.styp) in

+ let text = slist loc false sep s in

+ {used = used; text = text; styp = styp} :

+ ({used = [n.tvar]; text = TXnterm (loc, n, lev);

+ {used = [n.tvar]; text = TXnterm (loc, n, lev);

+ ({used = []; text = TXnext loc; styp = STself (loc, "NEXT")} :

+ ({used = []; text = TXself loc; styp = STself (loc, "SELF")} :

+(* Copyright 2002 Institut National de Recherche en Informatique et *)

+ (fun (s : 'symbol) _ (loc : int * int) -> (ssopt loc s : 'symbol));

+ (sslist loc min sep s : 'symbol))]]];;

+type 'a item_or_def =

+ SdStr of 'a

+ | SdDef of string

+ | SdUnd of string

+ | SdNop

+let not_yet_warned_variant = ref true;;

+let warn_variant () =

+ if !not_yet_warned_variant then

+ begin

+ not_yet_warned_variant := false;

+ Printf.eprintf "\

+*** warning: use of syntax of variants types deprecated since version 3.05\n";

+ flush stderr

+ end

+;;

+

+let warn_sequence () =

+*** warning: use of syntax of sequences deprecated since version 3.01.1\n";

+ and typevar : 'typevar Grammar.Entry.e = grammar_entry_create "typevar"

+ and warning_variant : 'warning_variant Grammar.Entry.e =

+ grammar_entry_create "warning_variant"

+ [Gramext.Stoken ("", "'");

+ Gramext.Snterm (Grammar.Entry.obj (ident : 'ident Grammar.Entry.e))],

+ Gramext.action

+ (fun (i : 'ident) _ (loc : int * int) ->

+ (MLast.MtQuo (loc, i) : 'module_type));

+ (Grammar.Entry.obj (module_expr : 'module_expr Grammar.Entry.e))],

+ (fun (me : 'module_expr) _ (i : 'mod_ident) _ (loc : int * int) ->

+ (MLast.WcMod (loc, i, me) : 'with_constr));

+ None, Some Gramext.LeftA,

+ [[Gramext.Stoken ("", "!");

+ Gramext.Slist1

+ (Gramext.Snterm

+ (Grammar.Entry.obj (typevar : 'typevar Grammar.Entry.e)));

+ Gramext.Stoken ("", "."); Gramext.Sself],

+ Gramext.action

+ (fun (t : 'ctyp) _ (pl : 'typevar list) _ (loc : int * int) ->

+ (MLast.TyPol (loc, pl, t) : 'ctyp))];

+ (MLast.CrMth (loc, l, false, fb, None) : 'class_str_item));

+ [Gramext.Stoken ("", "method");

+ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e));

+ Gramext.Stoken ("", ":");

+ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e));

+ Gramext.Stoken ("", "=");

+ Gramext.Snterm (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],

+ Gramext.action

+ (fun (e : 'expr) _ (t : 'ctyp) _ (l : 'label) _ (loc : int * int) ->

+ (MLast.CrMth (loc, l, false, e, Some t) : 'class_str_item));

+ (MLast.CrMth (loc, l, true, fb, None) : 'class_str_item));

+ [Gramext.Stoken ("", "method"); Gramext.Stoken ("", "private");

+ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e));

+ Gramext.Stoken ("", ":");

+ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e));

+ Gramext.Stoken ("", "=");

+ Gramext.Snterm (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],

+ Gramext.action

+ (fun (e : 'expr) _ (t : 'ctyp) _ (l : 'label) _ _ (loc : int * int) ->

+ (MLast.CrMth (loc, l, true, e, Some t) : 'class_str_item));

+ Grammar.Entry.obj (typevar : 'typevar Grammar.Entry.e), None,

+ [None, None,

+ [[Gramext.Stoken ("", "'");

+ Gramext.Snterm (Grammar.Entry.obj (ident : 'ident Grammar.Entry.e))],

+ Gramext.action

+ (fun (i : 'ident) _ (loc : int * int) -> (i : 'typevar))]];

+ [[Gramext.Stoken ("", "["); Gramext.Stoken ("", "<");

+ Gramext.Stoken ("", "]")],

+ [Gramext.Stoken ("", "["); Gramext.Stoken ("", "<");

+ Gramext.Stoken ("", "]")],

+ [Gramext.Stoken ("", "["); Gramext.Stoken ("", ">");

+ Gramext.Stoken ("", "]")],

+ [Gramext.Stoken ("", "["); Gramext.Stoken ("", "=");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", "]")],

+ (fun _ (rfl : 'row_field_list) _ _ (loc : int * int) ->

+ [[Gramext.Slist0sep

+ Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e),

+ Some (Gramext.Level "simple"),

+ [None, None,

+ [[Gramext.Stoken ("", "[|");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (warning_variant : 'warning_variant Grammar.Entry.e));

+ Gramext.Stoken ("", "<");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", ">");

+ Gramext.Slist1

+ (Gramext.Snterm

+ (Grammar.Entry.obj (name_tag : 'name_tag Grammar.Entry.e)));

+ Gramext.Stoken ("", "|]")],

+ Gramext.action

+ (fun _ (ntl : 'name_tag list) _ (rfl : 'row_field_list) _ _ _

+ (loc : int * int) ->

+ (MLast.TyVrn (loc, rfl, Some (Some ntl)) : 'ctyp));

+ [Gramext.Stoken ("", "[|");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (warning_variant : 'warning_variant Grammar.Entry.e));

+ Gramext.Stoken ("", "<");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", "|]")],

+ Gramext.action

+ (fun _ (rfl : 'row_field_list) _ _ _ (loc : int * int) ->

+ (MLast.TyVrn (loc, rfl, Some (Some [])) : 'ctyp));

+ [Gramext.Stoken ("", "[|");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (warning_variant : 'warning_variant Grammar.Entry.e));

+ Gramext.Stoken ("", ">");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", "|]")],

+ Gramext.action

+ (fun _ (rfl : 'row_field_list) _ _ _ (loc : int * int) ->

+ (MLast.TyVrn (loc, rfl, Some None) : 'ctyp));

+ [Gramext.Stoken ("", "[|");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (warning_variant : 'warning_variant Grammar.Entry.e));

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", "|]")],

+ Gramext.action

+ (fun _ (rfl : 'row_field_list) _ _ (loc : int * int) ->

+ (MLast.TyVrn (loc, rfl, None) : 'ctyp))]];

+ Grammar.Entry.obj (warning_variant : 'warning_variant Grammar.Entry.e),

+ None,

+ [None, None,

+ [[],

+ Gramext.action

+ (fun (loc : int * int) -> (warn_variant () : 'warning_variant))]];

+ (fun (loc : int * int) ->

+ (warn_sequence () : 'warning_sequence))]]]);;

+ SeTrm of MLast.loc * MLast.expr

+ | SeNtr of MLast.loc * MLast.expr

+ (MLast.PaApp (loc, MLast.PaUid (loc, "Some"), p)) skont

+ then

+let not_yet_warned_variant = ref true;;

+let warn_variant () =

+ if !not_yet_warned_variant then

+ begin

+ not_yet_warned_variant := false;

+ Printf.eprintf "\

+*** warning: use of syntax of variants types deprecated since version 3.05\n";

+ flush stderr

+ end

+;;

+

+let warn_sequence () =

+ Printf.eprintf "\

+*** warning: use of syntax of sequences deprecated since version 3.01.1\n";

+ and typevar : 'typevar Grammar.Entry.e = grammar_entry_create "typevar"

+ and warning_variant : 'warning_variant Grammar.Entry.e =

+ grammar_entry_create "warning_variant"

+ _ -> raise (Match_failure ("q_MLast.ml", 10073, 10089))

+ [Gramext.Stoken ("", "'");

+ Gramext.Snterm (Grammar.Entry.obj (ident : 'ident Grammar.Entry.e))],

+ Gramext.action

+ (fun (i : 'ident) _ (loc : int * int) ->

+ (Qast.Node ("MtQuo", [Qast.Loc; i]) : 'module_type));

+ _ -> raise (Match_failure ("q_MLast.ml", 12344, 12360))

+ (Grammar.Entry.obj (module_expr : 'module_expr Grammar.Entry.e))],

+ (fun (me : 'module_expr) _ (i : 'mod_ident) _ (loc : int * int) ->

+ (Qast.Node ("WcMod", [Qast.Loc; i; me]) : 'with_constr));

+ None, Some Gramext.LeftA,

+ [[Gramext.Stoken ("", "!");

+ Gramext.srules

+ [[Gramext.Slist1

+ (Gramext.Snterm

+ (Grammar.Entry.obj (typevar : 'typevar Grammar.Entry.e)))],

+ Gramext.action

+ (fun (a : 'typevar list) (loc : int * int) ->

+ (Qast.List a : 'a_list));

+ [Gramext.Snterm

+ (Grammar.Entry.obj (a_list : 'a_list Grammar.Entry.e))],

+ Gramext.action

+ (fun (a : 'a_list) (loc : int * int) -> (a : 'a_list))];

+ Gramext.Stoken ("", "."); Gramext.Sself],

+ Gramext.action

+ (fun (t : 'ctyp) _ (pl : 'a_list) _ (loc : int * int) ->

+ (Qast.Node ("TyPol", [Qast.Loc; pl; t]) : 'ctyp))];

+ (Qast.Node

+ ("CrMth",

+ [Qast.Loc; l; Qast.Bool false; fb; Qast.Option None]) :

+ 'class_str_item));

+ [Gramext.Stoken ("", "method");

+ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e));

+ Gramext.Stoken ("", ":");

+ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e));

+ Gramext.Stoken ("", "=");

+ Gramext.Snterm (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],

+ Gramext.action

+ (fun (e : 'expr) _ (t : 'ctyp) _ (l : 'label) _ (loc : int * int) ->

+ (Qast.Node

+ ("CrMth",

+ [Qast.Loc; l; Qast.Bool false; e; Qast.Option (Some t)]) :

+ (Qast.Node

+ ("CrMth", [Qast.Loc; l; Qast.Bool true; fb; Qast.Option None]) :

+ 'class_str_item));

+ [Gramext.Stoken ("", "method"); Gramext.Stoken ("", "private");

+ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e));

+ Gramext.Stoken ("", ":");

+ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e));

+ Gramext.Stoken ("", "=");

+ Gramext.Snterm (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],

+ Gramext.action

+ (fun (e : 'expr) _ (t : 'ctyp) _ (l : 'label) _ _ (loc : int * int) ->

+ (Qast.Node

+ ("CrMth",

+ [Qast.Loc; l; Qast.Bool true; e; Qast.Option (Some t)]) :

+ _ -> raise (Match_failure ("q_MLast.ml", 33221, 33237))

+ _ -> raise (Match_failure ("q_MLast.ml", 38172, 38188))

+ _ -> raise (Match_failure ("q_MLast.ml", 38519, 38535))

+ Grammar.Entry.obj (typevar : 'typevar Grammar.Entry.e), None,

+ [None, None,

+ [[Gramext.Stoken ("", "'");

+ Gramext.Snterm (Grammar.Entry.obj (ident : 'ident Grammar.Entry.e))],

+ Gramext.action

+ (fun (i : 'ident) _ (loc : int * int) -> (i : 'typevar))]];

+ [[Gramext.Stoken ("", "["); Gramext.Stoken ("", "<");

+ Gramext.Stoken ("", "]")],

+ [Gramext.Stoken ("", "["); Gramext.Stoken ("", "<");

+ Gramext.Stoken ("", "]")],

+ [Gramext.Stoken ("", "["); Gramext.Stoken ("", ">");

+ Gramext.Stoken ("", "]")],

+ [Gramext.Stoken ("", "["); Gramext.Stoken ("", "=");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", "]")],

+ (fun _ (rfl : 'row_field_list) _ _ (loc : int * int) ->

+ [[Gramext.Slist0sep

+ Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e),

+ Some (Gramext.Level "simple"),

+ [None, None,

+ [[Gramext.Stoken ("", "[|");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (warning_variant : 'warning_variant Grammar.Entry.e));

+ Gramext.Stoken ("", "<");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", ">");

+ Gramext.srules

+ [[Gramext.Slist1

+ (Gramext.Snterm

+ (Grammar.Entry.obj (name_tag : 'name_tag Grammar.Entry.e)))],

+ Gramext.action

+ (fun (a : 'name_tag list) (loc : int * int) ->

+ (Qast.List a : 'a_list));

+ [Gramext.Snterm

+ (Grammar.Entry.obj (a_list : 'a_list Grammar.Entry.e))],

+ Gramext.action

+ (fun (a : 'a_list) (loc : int * int) -> (a : 'a_list))];

+ Gramext.Stoken ("", "|]")],

+ Gramext.action

+ (fun _ (ntl : 'a_list) _ (rfl : 'row_field_list) _ _ _

+ (loc : int * int) ->

+ (Qast.Node

+ ("TyVrn",

+ [Qast.Loc; rfl; Qast.Option (Some (Qast.Option (Some ntl)))]) :

+ 'ctyp));

+ [Gramext.Stoken ("", "[|");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (warning_variant : 'warning_variant Grammar.Entry.e));

+ Gramext.Stoken ("", "<");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", "|]")],

+ Gramext.action

+ (fun _ (rfl : 'row_field_list) _ _ _ (loc : int * int) ->

+ (Qast.Node

+ ("TyVrn",

+ [Qast.Loc; rfl;

+ Qast.Option (Some (Qast.Option (Some (Qast.List []))))]) :

+ 'ctyp));

+ [Gramext.Stoken ("", "[|");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (warning_variant : 'warning_variant Grammar.Entry.e));

+ Gramext.Stoken ("", ">");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", "|]")],

+ Gramext.action

+ (fun _ (rfl : 'row_field_list) _ _ _ (loc : int * int) ->

+ (Qast.Node

+ ("TyVrn",

+ [Qast.Loc; rfl; Qast.Option (Some (Qast.Option None))]) :

+ 'ctyp));

+ [Gramext.Stoken ("", "[|");

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (warning_variant : 'warning_variant Grammar.Entry.e));

+ Gramext.Snterm

+ (Grammar.Entry.obj

+ (row_field_list : 'row_field_list Grammar.Entry.e));

+ Gramext.Stoken ("", "|]")],

+ Gramext.action

+ (fun _ (rfl : 'row_field_list) _ _ (loc : int * int) ->

+ (Qast.Node ("TyVrn", [Qast.Loc; rfl; Qast.Option None]) :

+ 'ctyp))]];

+ Grammar.Entry.obj (warning_variant : 'warning_variant Grammar.Entry.e),

+ None,

+ [None, None,

+ [[],

+ Gramext.action

+ (fun (loc : int * int) -> (warn_variant () : 'warning_variant))]];

+ (fun (loc : int * int) -> (warn_sequence () : 'warning_sequence))]];

+odyl_main.cmo: odyl_config.cmo odyl_main.cmi

+odyl_main.cmx: odyl_config.cmx odyl_main.cmi

+ Filename.check_suffix s ".cmo" || Filename.check_suffix s ".cma"

+ then

+ if Filename.check_suffix s ".cmo" || Filename.check_suffix s ".cma"

+ then