text stringlengths 12 786k |
|---|
module B = struct open Camlp4 open PreCast . Syntax open PreCast open Format module CleanAst = Camlp4 . Struct . CleanAst . Make ( Ast ) module SSet = Set . Make ( String ) let pa_r = " Camlp4OCamlRevisedParser " let pa_rr = " Camlp4OCamlReloadedParser " let pa_o = " Camlp4OCamlParser " let pa_rp = " Camlp4OCamlRevisedParserParser " let pa_op = " Camlp4OCamlParserParser " let pa_g = " Camlp4GrammarParser " let pa_m = " Camlp4MacroParser " let pa_qb = " Camlp4QuotationCommon " let pa_q = " Camlp4QuotationExpander " let pa_rq = " Camlp4OCamlRevisedQuotationExpander " let pa_oq = " Camlp4OCamlOriginalQuotationExpander " let pa_l = " Camlp4ListComprehension " open Register let dyn_loader = ref ( fun _ -> raise ( Match_failure ( " . / camlp4 / Camlp4Bin . ml " , 45 , 24 ) ) ) let rcall_callback = ref ( fun ( ) -> ( ) ) let loaded_modules = ref SSet . empty let add_to_loaded_modules name = loaded_modules := SSet . add name ! loaded_modules let ( objext , libext ) = if DynLoader . is_native then ( " . cmxs " , " . cmxs " ) else ( " . cmo " , " . cma " ) let rewrite_and_load n x = let dyn_loader = ! dyn_loader ( ) in let find_in_path = DynLoader . find_in_path dyn_loader in let real_load name = ( add_to_loaded_modules name ; DynLoader . load dyn_loader name ) in let load = List . iter ( fun n -> if ( SSet . mem n ! loaded_modules ) || ( List . mem n ! Register . loaded_modules ) then ( ) else ( add_to_loaded_modules n ; DynLoader . load dyn_loader ( n ^ objext ) ) ) in ( ( match ( n , ( String . lowercase x ) ) with | ( ( " Parsers " | " " ) , ( " pa_r . cmo " | " r " | " ocamlr " | " ocamlrevised " | " camlp4ocamlrevisedparser . cmo " ) ) -> load [ pa_r ] | ( ( " Parsers " | " " ) , ( " rr " | " reloaded " | " ocamlreloaded " | " camlp4ocamlreloadedparser . cmo " ) ) -> load [ pa_rr ] | ( ( " Parsers " | " " ) , ( " pa_o . cmo " | " o " | " ocaml " | " camlp4ocamlparser . cmo " ) ) -> load [ pa_r ; pa_o ] | ( ( " Parsers " | " " ) , ( " pa_rp . cmo " | " rp " | " rparser " | " camlp4ocamlrevisedparserparser . cmo " ) ) -> load [ pa_r ; pa_o ; pa_rp ] | ( ( " Parsers " | " " ) , ( " pa_op . cmo " | " op " | " parser " | " camlp4ocamlparserparser . cmo " ) ) -> load [ pa_r ; pa_o ; pa_rp ; pa_op ] | ( ( " Parsers " | " " ) , ( " pa_extend . cmo " | " pa_extend_m . cmo " | " g " | " grammar " | " camlp4grammarparser . cmo " ) ) -> load [ pa_g ] | ( ( " Parsers " | " " ) , ( " pa_macro . cmo " | " m " | " macro " | " camlp4macroparser . cmo " ) ) -> load [ pa_m ] | ( ( " Parsers " | " " ) , ( " q " | " camlp4quotationexpander . cmo " ) ) -> load [ pa_qb ; pa_q ] | ( ( " Parsers " | " " ) , ( " q_mlast . cmo " | " rq " | " camlp4ocamlrevisedquotationexpander . cmo " ) ) -> load [ pa_qb ; pa_rq ] | ( ( " Parsers " | " " ) , ( " oq " | " camlp4ocamloriginalquotationexpander . cmo " ) ) -> load [ pa_r ; pa_o ; pa_qb ; pa_oq ] | ( ( " Parsers " | " " ) , " rf " ) -> load [ pa_r ; pa_rp ; pa_qb ; pa_q ; pa_g ; pa_l ; pa_m ] | ( ( " Parsers " | " " ) , " of " ) -> load [ pa_r ; pa_o ; pa_rp ; pa_op ; pa_qb ; pa_rq ; pa_g ; pa_l ; pa_m ] | ( ( " Parsers " | " " ) , ( " comp " | " camlp4listcomprehension . cmo " ) ) -> load [ pa_l ] | ( ( " Filters " | " " ) , ( " lift " | " camlp4astlifter . cmo " ) ) -> load [ " Camlp4AstLifter " ] | ( ( " Filters " | " " ) , ( " exn " | " camlp4exceptiontracer . cmo " ) ) -> load [ " Camlp4ExceptionTracer " ] | ( ( " Filters " | " " ) , ( " prof " | " camlp4profiler . cmo " ) ) -> load [ " Camlp4Profiler " ] | ( ( " Filters " | " " ) , ( " map " | " camlp4mapgenerator . cmo " ) ) -> load [ " Camlp4FoldGenerator " ] | ( ( " Filters " | " " ) , ( " fold " | " camlp4foldgenerator . cmo " ) ) -> load [ " Camlp4FoldGenerator " ] | ( ( " Filters " | " " ) , ( " meta " | " camlp4metagenerator . cmo " ) ) -> load [ " Camlp4MetaGenerator " ] | ( ( " Filters " | " " ) , ( " trash " | " camlp4trashremover . cmo " ) ) -> load [ " Camlp4TrashRemover " ] | ( ( " Filters " | " " ) , ( " striploc " | " camlp4locationstripper . cmo " ) ) -> load [ " Camlp4LocationStripper " ] | ( ( " Printers " | " " ) , ( " pr_r . cmo " | " r " | " ocamlr " | " camlp4ocamlrevisedprinter . cmo " ) ) -> Register . enable_ocamlr_printer ( ) | ( ( " Printers " | " " ) , ( " pr_o . cmo " | " o " | " ocaml " | " camlp4ocamlprinter . cmo " ) ) -> Register . enable_ocaml_printer ( ) | ( ( " Printers " | " " ) , ( " pr_dump . cmo " | " p " | " dumpocaml " | " camlp4ocamlastdumper . cmo " ) ) -> Register . enable_dump_ocaml_ast_printer ( ) | ( ( " Printers " | " " ) , ( " d " | " dumpcamlp4 " | " camlp4astdumper . cmo " ) ) -> Register . enable_dump_camlp4_ast_printer ( ) | ( ( " Printers " | " " ) , ( " a " | " auto " | " camlp4autoprinter . cmo " ) ) -> load [ " Camlp4AutoPrinter " ] | _ -> let y = " Camlp4 " ^ ( n ^ ( " " / ^ ( x ^ objext ) ) ) in real_load ( try find_in_path y with | Not_found -> x ) ) ; ! rcall_callback ( ) ) let print_warning = eprintf " % a :\ n % s . " @ Loc . print let rec parse_file dyn_loader name pa getdir = let directive_handler = Some ( fun ast -> match getdir ast with | Some x -> ( match x with | ( _ , " load " , s ) -> ( rewrite_and_load " " s ; None ) | ( _ , " directory " , s ) -> ( DynLoader . include_dir dyn_loader s ; None ) | ( _ , " use " , s ) -> Some ( parse_file dyn_loader s pa getdir ) | ( _ , " default_quotation " , s ) -> ( Quotation . default := s ; None ) | ( loc , _ , _ ) -> Loc . raise loc ( Stream . Error " bad directive " ) ) | None -> None ) in let loc = Loc . mk name in ( current_warning := print_warning ; let ic = if name = " " - then stdin else open_in_bin name in let cs = Stream . of_channel ic in let clear ( ) = if name = " " - then ( ) else close_in ic in let phr = try pa ? directive_handler loc cs with | x -> ( clear ( ) ; raise x ) in ( clear ( ) ; phr ) ) let output_file = ref None let process dyn_loader name pa pr clean fold_filters getdir = let ast = parse_file dyn_loader name pa getdir in let ast = fold_filters ( fun t filter -> filter t ) ast in let ast = clean ast in pr ? input_file : ( Some name ) ? output_file : ! output_file ast let gind = function | Ast . SgDir ( loc , n , ( Ast . ExStr ( _ , s ) ) ) -> Some ( ( loc , n , s ) ) | _ -> None let gimd = function | Ast . StDir ( loc , n , ( Ast . ExStr ( _ , s ) ) ) -> Some ( ( loc , n , s ) ) | _ -> None let process_intf dyn_loader name = process dyn_loader name CurrentParser . parse_interf CurrentPrinter . print_interf ( new CleanAst . clean_ast ) # sig_item AstFilters . fold_interf_filters gind let process_impl dyn_loader name = process dyn_loader name CurrentParser . parse_implem CurrentPrinter . print_implem ( new CleanAst . clean_ast ) # str_item AstFilters . fold_implem_filters gimd let just_print_the_version ( ) = ( printf " % s . " @ Camlp4_config . version ; exit 0 ) let print_version ( ) = ( eprintf " Camlp4 version % s . " @ Camlp4_config . version ; exit 0 ) let print_stdlib ( ) = ( printf " % s . " @ Camlp4_config . camlp4_standard_library ; exit 0 ) let usage ini_sl ext_sl = ( eprintf " \ Options :\ n \ ( if DynLoader . is_native then " cmxs " else " ( cmo | cma ) " ) ; Options . print_usage_list ini_sl ; if ext_sl <> [ ] then ( eprintf " Options added by loaded object files . " ; :@ Options . print_usage_list ext_sl ) else ( ) ) let warn_noassert ( ) = eprintf " \ type file_kind = | Intf of string | Impl of string | Str of string | ModuleImpl of string | IncludeDir of string let search_stdlib = ref true let print_loaded_modules = ref false let ( task , do_task ) = let t = ref None in let task f x = let ( ) = Camlp4_config . current_input_file := x in t := Some ( if ! t = None then ( fun _ -> f x ) else ( fun usage -> usage ( ) ) ) in let do_task usage = match ! t with | Some f -> f usage | None -> ( ) in ( task , do_task ) let input_file x = let dyn_loader = ! dyn_loader ( ) in ( ! rcall_callback ( ) ; ( match x with | Intf file_name -> task ( process_intf dyn_loader ) file_name | Impl file_name -> task ( process_impl dyn_loader ) file_name | Str s -> let ( f , o ) = Filename . open_temp_file " from_string " " . ml " in ( output_string o s ; close_out o ; task ( process_impl dyn_loader ) f ; at_exit ( fun ( ) -> Sys . remove f ) ) | ModuleImpl file_name -> rewrite_and_load " " file_name | IncludeDir dir -> DynLoader . include_dir dyn_loader dir ) ; ! rcall_callback ( ) ) let initial_spec_list = [ ( " - I " , ( Arg . String ( fun x -> input_file ( IncludeDir x ) ) ) , " < directory > Add directory in search patch for object files . " ) ; ( " - where " , ( Arg . Unit print_stdlib ) , " Print camlp4 library directory and exit . " ) ; ( " - nolib " , ( Arg . Clear search_stdlib ) , " No automatic search for object files in library directory . " ) ; ( " - intf " , ( Arg . String ( fun x -> input_file ( Intf x ) ) ) , " < file > Parse < file > as an interface , whatever its extension . " ) ; ( " - impl " , ( Arg . String ( fun x -> input_file ( Impl x ) ) ) , " < file > Parse < file > as an implementation , whatever its extension . " ) ; ( " - str " , ( Arg . String ( fun x -> input_file ( Str x ) ) ) , " < string > Parse < string > as an implementation . " ) ; ( " - unsafe " , ( Arg . Set Camlp4_config . unsafe ) , " Generate unsafe accesses to array and strings . " ) ; ( " - noassert " , ( Arg . Unit warn_noassert ) , " Obsolete , do not use this option . " ) ; ( " - verbose " , ( Arg . Set Camlp4_config . verbose ) , " More verbose in parsing errors . " ) ; ( " - loc " , ( Arg . Set_string Loc . name ) , ( " < name > Name of the location variable ( default : " ^ ( ! Loc . name ^ " ) . " ) ) ) ; ( " - QD " , ( Arg . String ( fun x -> Quotation . dump_file := Some x ) ) , " < file > Dump quotation expander result in case of syntax error . " ) ; ( " - o " , ( Arg . String ( fun x -> output_file := Some x ) ) , " < file > Output on < file > instead of standard output . " ) ; ( " - v " , ( Arg . Unit print_version ) , " Print Camlp4 version and exit . " ) ; ( " - version " , ( Arg . Unit just_print_the_version ) , " Print Camlp4 version number and exit . " ) ; ( " - vnum " , ( Arg . Unit just_print_the_version ) , " Print Camlp4 version number and exit . " ) ; ( " - no_quot " , ( Arg . Clear Camlp4_config . quotations ) , " Don ' t parse quotations , allowing to use , e . g . " " \<:>\ as token . " ) ; ( " - loaded - modules " , ( Arg . Set print_loaded_modules ) , " Print the list of loaded modules . " ) ; ( " - parser " , ( Arg . String ( rewrite_and_load " Parsers " ) ) , " < name > Load the parser Camlp4Parsers /< name . > cm ( o | a | xs ) " ) ; ( " - printer " , ( Arg . String ( rewrite_and_load " Printers " ) ) , " < name > Load the printer Camlp4Printers /< name . > cm ( o | a | xs ) " ) ; ( " - filter " , ( Arg . String ( rewrite_and_load " Filters " ) ) , " < name > Load the filter Camlp4Filters /< name . > cm ( o | a | xs ) " ) ; ( " - ignore " , ( Arg . String ignore ) , " ignore the next argument " ) ; ( " " , -- ( Arg . Unit ignore ) , " Deprecated , does nothing " ) ] let _ = Options . init initial_spec_list let anon_fun name = input_file ( if Filename . check_suffix name " . mli " then Intf name else if Filename . check_suffix name " . ml " then Impl name else if Filename . check_suffix name objext then ModuleImpl name else if Filename . check_suffix name libext then ModuleImpl name else raise ( Arg . Bad ( " don ' t know what to do with " ^ name ) ) ) let main argv = let usage ( ) = ( usage initial_spec_list ( Options . ext_spec_list ( ) ) ; exit 0 ) in try let dynloader = DynLoader . mk ~ ocaml_stdlib : ! search_stdlib ~ camlp4_stdlib : ! search_stdlib ( ) in ( dyn_loader := ( fun ( ) -> dynloader ) ; let call_callback ( ) = Register . iter_and_take_callbacks ( fun ( name , module_callback ) -> let ( ) = add_to_loaded_modules name in module_callback ( ) ) in ( call_callback ( ) ; rcall_callback := call_callback ; ( match Options . parse anon_fun argv with | [ ] -> ( ) | ( " - help " | " -- help " | " - h " | " " ) -? :: _ -> usage ( ) | s :: _ -> ( eprintf " % s : unknown or misused option \ n " s ; eprintf " Use option - help for usage . " ; @ exit 2 ) ) ; do_task usage ; call_callback ( ) ; if ! print_loaded_modules then SSet . iter ( eprintf " % s . " ) @ ! loaded_modules else ( ) ) ) with | Arg . Bad s -> ( eprintf " Error : % s \ n " s ; eprintf " Use option - help for usage . " ; @ exit 2 ) | Arg . Help _ -> usage ( ) | exc -> ( eprintf " [ @< v0 >% a ] . " @@ ErrorHandler . print exc ; exit 2 ) let _ = main Sys . argv end |
module Id = struct value name = " Camlp4DebugParser " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) = struct open Sig ; include Syntax ; module StringSet = Set . Make String ; value debug_mode = try let str = Sys . getenv " STATIC_CAMLP4_DEBUG " in let rec loop acc i = try let pos = String . index_from str i ' ' : in loop ( StringSet . add ( String . sub str i ( pos - i ) ) acc ) ( pos + 1 ) with [ Not_found -> StringSet . add ( String . sub str i ( String . length str - i ) ) acc ] in let sections = loop StringSet . empty 0 in if StringSet . mem " " * sections then fun _ -> True else fun x -> StringSet . mem x sections with [ Not_found -> fun _ -> False ] ; value rec apply accu = fun [ [ ] -> accu | [ x :: xs ] -> let _loc = Ast . loc_of_expr x in apply <: expr < $ accu $ $ x $ >> xs ] ; value mk_debug_mode _loc = fun [ None -> <: expr < Debug . mode >> | Some m -> <: expr < $ uid : m . $ Debug . mode >> ] ; value mk_debug _loc m fmt section args = let call = apply <: expr < Debug . printf $ str : section $ $ str : fmt $ >> args in <: expr < if $ mk_debug_mode _loc m $ $ str : section $ then $ call $ else ( ) ; >> EXTEND Gram GLOBAL : expr ; expr : [ [ m = start_debug ; section = LIDENT ; fmt = STRING ; args = LIST0 expr LEVEL " . " ; x = end_or_in -> match ( x , debug_mode section ) with [ ( None , False ) -> <: expr < ( ) >> | ( Some e , False ) -> e | ( None , _ ) -> mk_debug _loc m fmt section args | ( Some e , _ ) -> <: expr < let ( ) = $ mk_debug _loc m fmt section args $ in $ e $ >> ] ] ] ; end_or_in : [ [ " end " -> None | " in " ; e = expr -> Some e ] ] ; start_debug : [ [ LIDENT " debug " -> None | LIDENT " camlp4_debug " -> Some " Camlp4 " ] ] ; END ; end ; |
let module M = Register . OCamlSyntaxExtension Id Make in ( ) ; |
module Id = struct value name = " Camlp4ExceptionTracer " ; value version = Sys . ocaml_version ; end ; |
module Make ( AstFilters : Camlp4 . Sig . AstFilters ) = struct open AstFilters ; open Ast ; value add_debug_expr e = let _loc = Ast . loc_of_expr e in let msg = " camlp4 - debug : exc : % s at " ^ Loc . to_string _loc ^ " . " @ in <: expr < try $ e $ with [ Stream . Failure | Exit as exc -> raise exc | exc -> do { if Debug . mode " exc " then Format . eprintf ` $ str : msg $ ( Printexc . to_string exc ) else ( ) ; raise exc } ] ; >> value rec map_match_case = fun [ <: match_case @ _loc < $ m1 $ | $ m2 $ >> -> <: match_case < $ map_match_case m1 $ | $ map_match_case m2 $ >> | <: match_case @ _loc < $ p $ when $ w $ -> $ e $ >> -> <: match_case @ _loc < $ p $ when $ w $ -> $ add_debug_expr e $ >> | m -> m ] ; value filter = object inherit Ast . map as super ; method expr = fun [ <: expr @ _loc < fun [ $ m $ ] >> -> <: expr < fun [ $ map_match_case m $ ] >> | x -> super # expr x ] ; method str_item = fun [ <: str_item < module Debug = $ _ $ >> as st -> st | st -> super # str_item st ] ; end ; register_str_item_filter filter # str_item ; end ; |
let module M = Camlp4 . Register . AstFilter Id Make in ( ) ; |
module Id = struct value name = " Camlp4FoldGenerator " ; value version = Sys . ocaml_version ; end ; |
module Make ( AstFilters : Camlp4 . Sig . AstFilters ) = struct open AstFilters ; module StringMap = Map . Make String ; open Ast ; value _loc = Loc . ghost ; value sf = Printf . sprintf ; value xik i k = let i = if i < 0 then assert False else if i = 0 then " " else sf " _i % d " i in let k = if k < 1 then assert False else if k = 1 then " " else sf " _k % d " k in sf " _x % s % s " i k ; value exik i k = <: expr < $ lid : xik i k $ ; >> value pxik i k = <: patt < $ lid : xik i k $ ; >> value elidk y k = <: expr < $ lid : sf " % s_ % d " y k $ ; >> value plidk y k = <: patt < $ lid : sf " % s_ % d " y k $ ; >> value xs s = " _x_ " ^ s ; value xsk = sf " _x_ % s_ % d " ; value exsk s k = <: expr < $ lid : xsk s k ; $>> value rec apply_expr accu = fun [ [ ] -> accu | [ x :: xs ] -> let _loc = Ast . loc_of_expr x in apply_expr <: expr < $ accu $ $ x $ >> xs ] ; value rec apply_patt accu = fun [ [ ] -> accu | [ x :: xs ] -> let _loc = Ast . loc_of_patt x in apply_patt <: patt < $ accu $ $ x $ >> xs ] ; value rec apply_ctyp accu = fun [ [ ] -> accu | [ x :: xs ] -> let _loc = Ast . loc_of_ctyp x in apply_ctyp <: ctyp < $ accu $ $ x $ >> xs ] ; value opt_map f = fun [ Some x -> Some ( f x ) | None -> None ] ; value list_init f n = let rec self m = if m = n then [ ] else [ f m :: self ( succ m ) ] in self 0 ; value rec lid_of_ident sep = fun [ <: ident < $ lid : s $ >> | <: ident < $ uid : s $ >> -> s | <: ident < $ i1 . $$ i2 $ >> -> lid_of_ident sep i1 ^ sep ^ lid_of_ident sep i2 | _ -> assert False ] ; type type_decl = ( string * Ast . ident * list Ast . ctyp * Ast . ctyp * bool ) ; value builtin_types = let tyMap = StringMap . empty in let tyMap = let abstr = [ " string " ; " int " ; " float " ; " int32 " ; " int64 " ; " nativeint " ; " char " ] in List . fold_right ( fun name -> StringMap . add name ( name , <: ident < $ lid : name $ , >> [ ] , <: ctyp , <>> False ) ) abstr tyMap in let tyMap = let concr = [ ( " bool " , <: ident < bool , >> [ ] , <: ctyp < [ False | True ] , >> False ) ; ( " list " , <: ident < list , >> [ <: ctyp < ' a >> ] , <: ctyp < [ $ uid " [ ] " :$ | $ uid " " :::$ of ' a and list ' a ] , >> False ) ; ( " option " , <: ident < option , >> [ <: ctyp < ' a >> ] , <: ctyp < [ None | Some of ' a ] , >> False ) ; ( " ref " , <: ident < ref , >> [ <: ctyp < ' a >> ] , <: ctyp < { contents : ' a } , >> False ) ] in List . fold_right ( fun ( ( name , _ , _ , _ , _ ) as decl ) -> StringMap . add name decl ) concr tyMap in tyMap ; value used_builtins = ref StringMap . empty ; value store_if_builtin_type id = if StringMap . mem id builtin_types then used_builtins . val := StringMap . add id ( StringMap . find id builtin_types ) used_builtins . val else ( ) ; type mode = [ Fold | Map | Fold_map ] ; value string_of_mode = fun [ Fold -> " fold " | Map -> " map " | Fold_map -> " fold_map " ] ; module Gen ( X : sig value size : int ; value mode : mode ; end ) = struct value size = X . size ; value mode = X . mode ; value tuplify_expr f = if size <= 0 then assert False else if size = 1 then f 1 else let rec loop k = if k = 2 then f 2 else <: expr < $ loop ( k - 1 ) , $ $ f k $ >> in <: expr < ( $ f 1 , $ $ loop size ) $ ; >> value tuplify_patt f = if size <= 0 then assert False else if size = 1 then f 1 else let rec loop k = if k = 2 then f 2 else <: patt < $ loop ( k - 1 ) , $ $ f k $ >> in <: patt < ( $ f 1 , $ $ loop size ) $ ; >> value xiks i = tuplify_expr ( exik i ) ; value tuplify_type typ = if size <= 0 then assert False else if size = 1 then typ else let rec loop k = if k = 2 then typ else <: ctyp < $ loop ( k - 1 ) $ * $ typ $ >> in <: ctyp < ( $ typ $ * $ loop size ) $ ; >> value tuplify_tycon tycon = tuplify_type <: ctyp < $ lid : tycon $ ; >> value rec patt_of_expr = fun [ <: expr <>> -> <: patt <>> | <: expr < $ id : i $ >> -> <: patt < $ id : i $ >> | <: expr < $ e1 , $ $ e2 $ >> -> <: patt < $ patt_of_expr e1 , $ $ patt_of_expr e2 $ >> | <: expr < $ tup : e $ >> -> <: patt < $ tup : patt_of_expr e $ >> | _ -> assert False ] ; value bind p e1 e2 = match mode with [ Fold_map -> <: expr < let ( o , $ p ) $ = $ e1 $ in $ e2 $ >> | Map -> <: expr < let $ p $ = $ e1 $ in $ e2 $ >> | Fold -> <: expr < let o = $ e1 $ in $ e2 $ >> ] ; value return e = match mode with [ Fold_map -> <: expr < ( o , $ e ) $ >> | Map -> e | Fold -> <: expr < o >> ] ; value rec opt_bind opt_patt e1 mk_e2 = match e1 with [ <: expr < $ id : _ $ >> | <: expr < $ lid : _ $#$ _ $ >> -> mk_e2 e1 | <: expr < let $ p1 $ = $ e1 $ in $ e2 $ >> -> <: expr < let $ p1 $ = $ e1 $ in $ opt_bind None e2 mk_e2 $ >> | _ -> let e2 = mk_e2 <: expr < o >> in match opt_patt with [ Some patt -> bind patt e1 e2 | None -> <: expr < ( fun o -> $ e1 ) $ $ e2 $ >> ] ] ; value chain_tuple mkp mke expr_of_ty ts = let exiks = list_init ( fun i -> tuplify_expr ( exik i ) ) ( List . length ts ) in let exi1s = list_init ( fun i -> exik i 1 ) ( List . length ts ) in let pxi1s = list_init ( fun i -> pxik i 1 ) ( List . length ts ) in let ps k = mkp ( list_init ( fun i -> pxik i k ) ( List . length ts ) ) in let p = tuplify_patt ps in let e1 = mke exi1s in let es = List . map2 ( fun x -> expr_of_ty ( Some x ) ) exiks ts in let e = List . fold_right2 begin fun pxi1 e acc -> bind pxi1 e acc end pxi1s es ( return e1 ) in <: match_case < $ p $ -> $ e $ ; >> value mk_tuple expr_of_ty t = let mc = chain_tuple ( fun ps -> <: patt < ( $ tup : Ast . paCom_of_list ps ) $ ) >> ( fun es -> <: expr < ( $ tup : Ast . exCom_of_list es ) $ ) >> expr_of_ty ( Ast . list_of_ctyp t [ ] ) in <: expr < fun [ $ mc $ ] ; >> value default_match_case = let mk k = if k = 1 then <: patt < x >> else <: patt < _ >> in match mode with [ Fold_map -> <: match_case < $ tuplify_patt mk $ -> ( o , x ) >> | Fold -> <: match_case < _ -> o >> | Map -> <: match_case < $ tuplify_patt mk $ -> x >> ] ; value default_expr = <: expr < fun [ $ default_match_case $ ] ; >> value mkfuno e = match e with [ <: expr < $ e $ o >> -> e | _ -> <: expr < fun o -> $ e $ >> ] ; value is_unknown t = let rec loop t = match t with [ <: ctyp < $ lid : _ $ >> -> False | <: ctyp < $ id : _ $ >> -> True | <: ctyp < $ t $ $ _ $ >> -> loop t | _ -> False ] in match t with [ <: ctyp < $ uid : _ $ >> -> False | t -> loop t ] ; value contains_unknown t = try let ( _ : < . . ) > = object inherit Ast . fold as super ; method ctyp t = if is_unknown t then raise Exit else super # ctyp t ; end # ctyp t in False with [ Exit -> True ] ; value opt_bind ' ox e1 mk_e2 = let mk_e2 = match ox with [ Some x -> fun e1 -> <: expr < $ mk_e2 e1 $ $ x $ >> | _ -> mk_e2 ] in opt_bind ( opt_map patt_of_expr ox ) e1 mk_e2 ; value opt_app e ox = match ox with [ Some x -> <: expr < $ e $ $ x $ >> | _ -> e ] ; value rec expr_of_ty x ty = let rec self ( ? arity = 0 ) ox = fun [ t when is_unknown t -> self ox <: ctyp < unknown >> | <: ctyp < $ lid : id $ >> -> let ( ) = store_if_builtin_type id in opt_bind ' ox <: expr < o >> ( fun e1 -> <: expr < $ e1 $#$ id $ ) >> | <: ctyp @ _loc < $ t1 $ $ t2 $ >> -> let e = opt_bind None ( self ~ arity ( : arity + 1 ) None t1 ) ( fun e1 -> <: expr < $ e1 $ $ mkfuno ( self None t2 ) $ ) >> in opt_app e ox | <: ctyp < ( $ tup : t $ ) >> -> opt_app ( mk_tuple ( self ~ arity : 0 ) t ) ox | <: ctyp < ' $ s $ >> -> opt_app <: expr < $ lid " : _f_ " ^ s $ o >> ox | _ -> self ox <: ctyp < unknown >> ] in self x ty and expr_of_ty ' e t = expr_of_ty ( Some e ) t and out_constr_patt s = <: patt < $ uid : s $ >> and out_constr_expr s = <: expr < $ uid : s $ >> and match_case_of_constructor s t = chain_tuple ( apply_patt ( out_constr_patt s ) ) ( apply_expr ( out_constr_expr s ) ) expr_of_ty ( Ast . list_of_ctyp t [ ] ) and match_case_of_sum_type = fun [ <: ctyp < $ t1 $ | $ t2 $ >> -> <: match_case < $ match_case_of_sum_type t1 $ | $ match_case_of_sum_type t2 $ >> | <: ctyp < $ uid : s $ of $ t $ >> -> match_case_of_constructor s t | <: ctyp < $ uid : s $ >> -> match_case_of_constructor s <: ctyp <>> | _ -> assert False ] and match_case_of_poly_constructor s ts = chain_tuple ( fun [ [ ] -> <: patt < ` $ s $ >> | [ p ] -> <: patt < ` $ s $ $ p $ >> | ps -> <: patt < ` $ s $ ( $ tup : Ast . paCom_of_list ps ) $ >> ] ) ( fun [ [ ] -> <: expr < ` $ s $ >> | [ e ] -> <: expr < ` $ s $ $ e $ >> | es -> <: expr < ` $ s $ ( $ tup : Ast . exCom_of_list es ) $ >> ] ) expr_of_ty ts and match_case_of_poly_sum_type = fun [ <: ctyp < $ t1 $ | $ t2 $ >> -> <: match_case < $ match_case_of_poly_sum_type t1 $ | $ match_case_of_poly_sum_type t2 $ >> | <: ctyp < ` $ i $ of ( $ tup : t ) $ >> -> match_case_of_poly_constructor i ( Ast . list_of_ctyp t [ ] ) | <: ctyp < ` $ i $ of $ t $ >> -> match_case_of_poly_constructor i [ t ] | <: ctyp < ` $ i $ >> -> match_case_of_poly_constructor i [ ] | _ -> assert False ] and record_patt_of_type k = fun [ <: ctyp < $ lid : s $ : $ _ $ >> -> <: patt < $ lid : s $ = $ lid : xsk s k $ >> | <: ctyp < $ t1 $ ; $ t2 $ >> -> <: patt < $ record_patt_of_type k t1 ; $ $ record_patt_of_type k t2 $ >> | _ -> assert False ] and type_list_of_record_type t ( ( acc1 , acc2 ) as acc ) = match t with [ <: ctyp <>> -> acc | <: ctyp < $ lid : s $ : mutable $ t $ >> | <: ctyp < $ lid : s $ : $ t $ >> -> ( [ s :: acc1 ] , [ t :: acc2 ] ) | <: ctyp < $ t1 $ ; $ t2 $ >> -> type_list_of_record_type t1 ( type_list_of_record_type t2 acc ) | _ -> assert False ] and expr_of_record_type t = let ( ls , ts ) = type_list_of_record_type t ( [ ] , [ ] ) in let mkp ps = <: patt < { $ list : List . map2 ( fun l p -> <: patt < $ lid : l $ = $ p $ ) >> ls ps $ } >> in let mke es = <: expr < { $ list : List . map2 ( fun l e -> <: rec_binding < $ lid : l $ = $ e $ ) >> ls es $ } >> in chain_tuple mkp mke expr_of_ty ts and failure_match_case = <: match_case < $ tuplify_patt ( pxik 0 ) $ -> o #$ lid : sf " % s % d_failure " ( string_of_mode mode ) size $ $ tuplify_expr ( exik 0 ) $ >> and complete_match_case mk t = match t with [ <: ctyp < $ _ $ | $ _ $ >> when size > 1 -> <: match_case < $ mk t $ | $ failure_match_case $ >> | _ -> mk t ] and fun_of_ctyp tyid = fun [ <: ctyp < [ $ t $ ] >> -> <: expr < fun [ $ complete_match_case match_case_of_sum_type t $ ] >> | <: ctyp < { $ t $ } >> -> <: expr < fun [ $ expr_of_record_type t $ ] >> | <: ctyp < ( $ tup : t $ ) >> -> mk_tuple expr_of_ty t | <: ctyp < $ lid : i $ >> when i = tyid -> default_expr | <: ctyp < $ _ $ $ _ $ >> | <: ctyp < $ _ $ -> $ _ $ >> | <: ctyp < ' $ _ $ >> | <: ctyp < $ id : _ $ >> as t -> expr_of_ty None t | <: ctyp <>> -> expr_of_ty None <: ctyp < unknown >> | <: ctyp < [ = $ t $ ] >> | <: ctyp < [ < $ t $ ] >> | <: ctyp < private [ < $ t $ ] >> -> <: expr < fun [ $ complete_match_case match_case_of_poly_sum_type t $ ] >> | <: ctyp < [ > $ t $ ] >> | <: ctyp < private [ > $ t $ ] >> -> if size > 1 then <: expr < fun [ $ complete_match_case match_case_of_poly_sum_type t $ ] >> else <: expr < fun [ $ match_case_of_poly_sum_type t $ | $ default_match_case $ ] >> | _ -> assert False ] and string_of_type_param t = match t with [ <: ctyp < ' $ s $ >> | <: ctyp < ' +$ s $ >> | <: ctyp < ' -$ s $ >> -> s | _ -> assert False ] and method_of_type_decl _ ( ( id1 , _ , params , ctyp , priv ) as type_decl ) acc = let rec lambda acc = fun [ [ ] -> acc | [ x :: xs ] -> lambda <: expr < fun $ lid " : _f_ " ^ x $ -> $ acc $ >> xs ] in let params ' = List . map string_of_type_param params in let funs = lambda ( fun_of_ctyp id1 ctyp ) params ' in let ty = method_type_of_type_decl type_decl in let priv = if priv then <: private_flag < private >> else <: private_flag <>> in <: class_str_item < method $ private : priv $ $ lid : id1 $ : $ ty $ = $ funs ; $ $ acc $ >> and ctyp_name_of_name_params name params = apply_ctyp <: ctyp < $ id : name $ >> params and method_type_of_type_decl ( _ , name , params , ctyp , _ ) = let t = ctyp_name_of_name_params name params in if mode = Map && not ( contains_unknown ctyp ) then let out_params = List . map ( fun [ <: ctyp < ' $ i $ >> -> <: ctyp < ' $ i " ^ _out " $ >> | _ -> assert False ] ) params in let t_out = ctyp_name_of_name_params name out_params in method_type_of_type t t_out params out_params else method_type_of_type t t params [ ] and method_type_of_type t_in t_out params_in params_out = let rt t = match mode with [ Fold_map -> <: ctyp < ( ' self_type * $ t ) $ >> | Fold -> <: ctyp < ' self_type >> | Map -> t ] in match ( params_in , params_out ) with [ ( [ param_in ] , [ param_out ] ) -> let alphas = tuplify_type param_in in <: ctyp < ! $ param_in $ $ param_out $ . ( ' self_type -> $ alphas $ -> $ rt param_out ) $ -> $ tuplify_type t_in $ -> $ rt t_out $ >> | ( [ param ] , [ ] ) -> let alphas = tuplify_type param in <: ctyp < ! $ param $ . ( ' self_type -> $ alphas $ -> $ rt param ) $ -> $ tuplify_type t_in $ -> $ rt t_out $ >> | ( [ ] , [ ] ) -> <: ctyp < $ tuplify_type t_in $ -> $ rt t_out $ >> | _ -> let i = List . length params_in in failwith ( Printf . sprintf " Camlp4FoldGenerator : FIXME not implemented for types with % d parameters " i ) ] and class_sig_item_of_type_decl _ ( ( name , _ , _ , t , _ ) as type_decl ) acc = let ( _ : < . . ) > = object ( self ) inherit Ast . fold as super ; method ctyp = fun [ <: ctyp < $ lid : id $ >> -> let ( ) = store_if_builtin_type id in self | t -> super # ctyp t ] ; end # ctyp t in <: class_sig_item < method $ lid : name $ : $ method_type_of_type_decl type_decl ; $ $ acc $ >> and generate_structure tyMap = StringMap . fold method_of_type_decl used_builtins . val ( StringMap . fold method_of_type_decl tyMap <: class_str_item ) <>> and generate_signature tyMap = StringMap . fold class_sig_item_of_type_decl used_builtins . val ( StringMap . fold class_sig_item_of_type_decl tyMap <: class_sig_item ) ; <>> end ; value rec tyMap_of_type_decls t acc = match t with [ <: ctyp <>> -> acc | <: ctyp < $ t1 $ and $ t2 $ >> -> tyMap_of_type_decls t1 ( tyMap_of_type_decls t2 acc ) | Ast . TyDcl _ name tl tk _ -> StringMap . add name ( name , <: ident < $ lid : name $ , >> tl , tk , False ) acc | _ -> assert False ] ; value generate_class_implem mode c tydcl n = let tyMap = tyMap_of_type_decls tydcl StringMap . empty in let module M = Gen ( struct value size = n ; value mode = mode ; end ) in let generated = M . generate_structure tyMap in let gen_type = <: ctyp < ! ' a ' b . $ M . method_type_of_type <: ctyp < ' a >> <: ctyp < ' b >> [ ] [ ] $ >> in let failure = if n > 1 then let name = string_of_mode mode in <: class_str_item < method $ lid : sf " % s % d_failure " name n $ : $ gen_type $ = fun $ M . tuplify_patt ( pxik 0 ) $ -> failwith ` $ str : sf " % s % d_failure : default implementation " name n $ >> else <: class_str_item <>> in let gen_type = <: ctyp < ! ' a . $ M . method_type_of_type <: ctyp < ' a >> <: ctyp < ' a >> [ ] [ ] $ >> in let unknown = <: class_str_item < method unknown : $ gen_type $ = $ M . default_expr $ >> in <: str_item < class $ lid : c $ = object ( o : ' self_type ) $ generated ; $ $ failure ; $ $ unknown $ end ; >> value generate_class_interf mode c tydcl n = let tyMap = tyMap_of_type_decls tydcl StringMap . empty in let module M = Gen ( struct value size = n ; value mode = mode ; end ) in let generated = M . generate_signature tyMap in let gen_type = <: ctyp < ! ' a ' b . $ M . method_type_of_type <: ctyp < ' a >> <: ctyp < ' b >> [ ] [ ] $ >> in let failure = if n > 1 then let name = string_of_mode mode in <: class_sig_item < method $ lid : sf " % s % d_failure " name n $ : $ gen_type $ >> else <: class_sig_item <>> in let gen_type = <: ctyp < ! ' a . $ M . method_type_of_type <: ctyp < ' a >> <: ctyp < ' a >> [ ] [ ] $ >> in let unknown = <: class_sig_item < method unknown : $ gen_type $ >> in <: sig_item < class $ lid : c $ : object ( ' self_type ) $ generated ; $ $ failure ; $ $ unknown $ end ; >> value processor = let last = ref <: ctyp <>> in let generate_class ' generator default c s n = match s with [ " Fold " -> generator Fold c last . val n | " Map " -> generator Map c last . val n | " FoldMap " -> generator Fold_map c last . val n | _ -> default ] in let generate_class_from_module_name generator c default m = try Scanf . sscanf m " Camlp4 [ %^ G ] Generator " begin fun m ' -> try Scanf . sscanf m ' " [ %^ 0 - 9 ] % d " ( generate_class ' generator default c ) with [ End_of_file | Scanf . Scan_failure _ -> generate_class ' generator default c m ' 1 ] end with [ End_of_file | Scanf . Scan_failure _ -> default ] in object ( self ) inherit Ast . map as super ; method str_item st = match st with [ <: str_item < type $ t $ >> -> ( last . val := t ; st ) | <: str_item @ _loc < class $ lid : c $ = Camlp4Filters . GenerateFold . generated >> -> generate_class_implem Fold c last . val 1 | <: str_item @ _loc < class $ lid : c $ = Camlp4Filters . GenerateMap . generated >> -> generate_class_implem Map c last . val 1 | <: str_item @ _loc < class $ lid : c $ = $ uid : m . $ generated >> -> generate_class_from_module_name generate_class_implem c st m | <: str_item < $ st1 ; $ $ st2 $ >> -> let st1 = self # str_item st1 in <: str_item < $ st1 ; $ $ self # str_item st2 $ >> | st -> super # str_item st ] ; method sig_item sg = match sg with [ <: sig_item < type $ t $ >> -> ( last . val := t ; sg ) | <: sig_item @ _loc < class $ lid : c $ : Camlp4Filters . GenerateFold . generated >> -> generate_class_interf Fold c last . val 1 | <: sig_item @ _loc < class $ lid : c $ : Camlp4Filters . GenerateMap . generated >> -> generate_class_interf Map c last . val 1 | <: sig_item @ _loc < class $ lid : c $ : $ uid : m . $ generated >> -> generate_class_from_module_name generate_class_interf c sg m | <: sig_item < $ sg1 ; $ $ sg2 $ >> -> let sg1 = self # sig_item sg1 in <: sig_item < $ sg1 ; $ $ self # sig_item sg2 $ >> | sg -> super # sig_item sg ] ; end ; register_str_item_filter processor # str_item ; register_sig_item_filter processor # sig_item ; end ; |
let module M = Camlp4 . Register . AstFilter Id Make in ( ) ; |
module Id = struct value name = " Camlp4GrammarParser " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) = struct open Sig ; include Syntax ; module MetaLoc = Ast . Meta . MetaGhostLoc ; module MetaAst = Ast . Meta . Make MetaLoc ; module PP = Camlp4 . Printers . OCaml . Make Syntax ; value pp = new PP . printer ~ comments : False ( ) ; value string_of_patt patt = let buf = Buffer . create 42 in let ( ) = Format . bprintf buf " % a " @? pp # patt patt in let str = Buffer . contents buf in if str = " " then assert False else str ; value split_ext = ref False ; type loc = Loc . t ; type name ' e = { expr : ' e ; tvar : string ; loc : loc } ; type styp = [ STlid of loc and string | STapp of loc and styp and styp | STquo of loc and string | STself of loc and string | STtok of loc | STstring_tok of loc | STtyp of Ast . ctyp ] ; type text ' e ' p = [ TXmeta of loc and string and list ( text ' e ' p ) and ' e and styp | TXlist of loc and bool and symbol ' e ' p and option ( symbol ' e ' p ) | TXnext of loc | TXnterm of loc and name ' e and option string | TXopt of loc and text ' e ' p | TXtry of loc and text ' e ' p | TXrules of loc and list ( list ( text ' e ' p ) * ' e ) | TXself of loc | TXkwd of loc and string | TXtok of loc and ' e and string ] and entry ' e ' p = { name : name ' e ; pos : option ' e ; levels : list ( level ' e ' p ) } and level ' e ' p = { label : option string ; assoc : option ' e ; rules : list ( rule ' e ' p ) } and rule ' e ' p = { prod : list ( symbol ' e ' p ) ; action : option ' e } and symbol ' e ' p = { used : list string ; text : text ' e ' p ; styp : styp ; pattern : option ' p } ; type used = [ Unused | UsedScanned | UsedNotScanned ] ; value _loc = Loc . ghost ; value gm = " Camlp4Grammar__ " ; value mark_used modif ht n = try let rll = Hashtbl . find_all ht n in List . iter ( fun ( r , _ ) -> if r . val == Unused then do { r . val := UsedNotScanned ; modif . val := True ; } else ( ) ) rll with [ Not_found -> ( ) ] ; value rec mark_symbol modif ht symb = List . iter ( fun e -> mark_used modif ht e ) symb . used ; value check_use nl el = let ht = Hashtbl . create 301 in let modif = ref False in do { List . iter ( fun e -> let u = match e . name . expr with [ <: expr < $ lid : _ $ >> -> Unused | _ -> UsedNotScanned ] in Hashtbl . add ht e . name . tvar ( ref u , e ) ) el ; List . iter ( fun n -> try let rll = Hashtbl . find_all ht n . tvar in List . iter ( fun ( r , _ ) -> r . val := UsedNotScanned ) rll with _ -> ( ) ) nl ; modif . val := True ; while modif . val do { modif . val := False ; Hashtbl . iter ( fun _ ( r , e ) -> if r . val = UsedNotScanned then do { r . val := UsedScanned ; List . iter ( fun level -> let rules = level . rules in List . iter ( fun rule -> List . iter ( fun s -> mark_symbol modif ht s ) rule . prod ) rules ) e . levels } else ( ) ) ht } ; Hashtbl . iter ( fun s ( r , e ) -> if r . val = Unused then print_warning e . name . loc ( " Unused local entry " " \ ^ s ^ " " " ) \ else ( ) ) ht ; } ; value new_type_var = let i = ref 0 in fun ( ) -> do { incr i ; " e__ " ^ string_of_int i . val } ; value used_of_rule_list rl = List . fold_left ( fun nl r -> List . fold_left ( fun nl s -> s . used @ nl ) nl r . prod ) [ ] rl ; value retype_rule_list_without_patterns _loc rl = try List . map ( fun [ { prod = [ ( { pattern = None ; styp = STtok _ } as s ) ] ; action = None } -> { prod = [ { ( s ) with pattern = Some <: patt < x >> } ] ; action = Some <: expr < $ uid : gm . $ Token . extract_string x } >> | { prod = [ ( { pattern = None } as s ) ] ; action = None } -> { prod = [ { ( s ) with pattern = Some <: patt < x >> } ] ; action = Some <: expr < x } >> | { prod = [ ] ; action = Some _ } as r -> r | _ -> raise Exit ] ) rl with [ Exit -> rl ] ; value meta_action = ref False ; value mklistexp _loc = loop True where rec loop top = fun [ [ ] -> <: expr < [ ] >> | [ e1 :: el ] -> let _loc = if top then _loc else Loc . merge ( Ast . loc_of_expr e1 ) _loc in <: expr < [ $ e1 $ :: $ loop False el ] $ >> ] ; value mklistpat _loc = loop True where rec loop top = fun [ [ ] -> <: patt < [ ] >> | [ p1 :: pl ] -> let _loc = if top then _loc else Loc . merge ( Ast . loc_of_patt p1 ) _loc in <: patt < [ $ p1 $ :: $ loop False pl ] $ >> ] ; value rec expr_fa al = fun [ <: expr < $ f $ $ a $ >> -> expr_fa [ a :: al ] f | f -> ( f , al ) ] ; value rec make_ctyp styp tvar = match styp with [ STlid _loc s -> <: ctyp < $ lid : s $ >> | STapp _loc t1 t2 -> <: ctyp < $ make_ctyp t1 tvar $ $ make_ctyp t2 tvar $ >> | STquo _loc s -> <: ctyp < ' $ s $ >> | STself _loc x -> if tvar = " " then Loc . raise _loc ( Stream . Error ( " ' " ^ x ^ " ' illegal in anonymous entry level " ) ) else <: ctyp < ' $ tvar $ >> | STtok _loc -> <: ctyp < $ uid : gm . $ Token . t >> | STstring_tok _loc -> <: ctyp < string >> | STtyp t -> t ] ; value make_ctyp_patt styp tvar patt = let styp = match styp with [ STstring_tok _loc -> STtok _loc | t -> t ] in match make_ctyp styp tvar with [ <: ctyp < _ >> -> patt | t -> let _loc = Ast . loc_of_patt patt in <: patt < ( $ patt $ : $ t ) $ >> ] ; value make_ctyp_expr styp tvar expr = match make_ctyp styp tvar with [ <: ctyp < _ >> -> expr | t -> let _loc = Ast . loc_of_expr expr in <: expr < ( $ expr $ : $ t ) $ >> ] ; value text_of_action _loc psl rtvar act tvar = let locid = <: patt < $ lid : Loc . name . val $ >> in let act = match act with [ Some act -> act | None -> <: expr < ( ) >> ] in let ( tok_match_pl , act , _ ) = List . fold_left ( fun ( ( tok_match_pl , act , i ) as accu ) -> fun [ { pattern = None } -> accu | { pattern = Some p } when Ast . is_irrefut_patt p -> accu | { pattern = Some <: patt < ( $ _ $ ( $ tup :<: patt < _ ) >>$ as $ lid : s ) $ >> } -> ( tok_match_pl , <: expr < let $ lid : s $ = $ uid : gm . $ Token . extract_string $ lid : s $ in $ act $ , >> i ) | { pattern = Some p ; text = TXtok _ _ _ } -> let id = " __camlp4_ " ^ string_of_int i in ( Some ( match ( tok_match_pl ) with [ None -> ( <: expr < $ lid : id $ , >> p ) | Some ( tok_pl , match_pl ) -> ( <: expr < $ lid : id , $ $ tok_pl $ , >> <: patt < $ p , $ $ match_pl $ ) ] ) , >> act , succ i ) | _ -> accu ] ) ( None , act , 0 ) psl in let e = let e1 = <: expr < ( $ act $ : ' $ rtvar ) $ >> in let e2 = match ( tok_match_pl ) with [ None -> e1 | Some ( <: expr < $ t1 , $ $ t2 $ , >> <: patt < $ p1 , $ $ p2 $ ) >> -> <: expr < match ( $ t1 , $ $ t2 ) $ with [ ( $ p1 , $ $ p2 ) $ -> $ e1 $ | _ -> assert False ] >> | Some ( tok , match_ ) -> <: expr < match $ tok $ with [ $ pat : match_ $ -> $ e1 $ | _ -> assert False ] >> ] in <: expr < fun ( $ locid $ : $ uid : gm . $ Loc . t ) -> $ e2 $ >> in let ( txt , _ ) = List . fold_left ( fun ( txt , i ) s -> match s . pattern with [ None | Some <: patt < _ >> -> ( <: expr < fun _ -> $ txt $ , >> i ) | Some <: patt < ( $ _ $ ( $ tup :<: patt < _ ) >>$ as $ p ) $ >> -> let p = make_ctyp_patt s . styp tvar p in ( <: expr < fun $ p $ -> $ txt $ , >> i ) | Some p when Ast . is_irrefut_patt p -> let p = make_ctyp_patt s . styp tvar p in ( <: expr < fun $ p $ -> $ txt $ , >> i ) | Some _ -> let p = make_ctyp_patt s . styp tvar <: patt < $ lid " : __camlp4_ " ^ string_of_int i $ >> in ( <: expr < fun $ p $ -> $ txt $ , >> succ i ) ] ) ( e , 0 ) psl in let txt = if meta_action . val then <: expr < Obj . magic $ MetaAst . Expr . meta_expr _loc txt $ >> else txt in <: expr < $ uid : gm . $ Action . mk $ txt $ >> ; value srules loc t rl tvar = List . map ( fun r -> let sl = [ s . text | s <- r . prod ] in let ac = text_of_action loc r . prod t r . action tvar in ( sl , ac ) ) rl ; value rec make_expr entry tvar = fun [ TXmeta _loc n tl e t -> let el = List . fold_right ( fun t el -> <: expr < [ $ make_expr entry " " t $ :: $ el ] $ ) >> tl <: expr < [ ] >> in <: expr < $ uid : gm . $ Smeta $ str : n $ $ el $ ( $ uid : gm . $ Action . mk ( $ make_ctyp_expr t tvar e ) ) $ >> | TXlist _loc min t ts -> let txt = make_expr entry " " t . text in match ( min , ts ) with [ ( False , None ) -> <: expr < $ uid : gm . $ Slist0 $ txt $ >> | ( True , None ) -> <: expr < $ uid : gm . $ Slist1 $ txt $ >> | ( False , Some s ) -> let x = make_expr entry tvar s . text in <: expr < $ uid : gm . $ Slist0sep $ txt $ $ x $ >> | ( True , Some s ) -> let x = make_expr entry tvar s . text in <: expr < $ uid : gm . $ Slist1sep $ txt $ $ x $ >> ] | TXnext _loc -> <: expr < $ uid : gm . $ Snext >> | TXnterm _loc n lev -> match lev with [ Some lab -> <: expr < $ uid : gm . $ Snterml ( $ uid : gm . $ Entry . obj ( $ n . expr $ : $ uid : gm . $ Entry . t ' $ n . tvar ) ) $ $ str : lab $ >> | None -> if n . tvar = tvar then <: expr < $ uid : gm . $ Sself >> else <: expr < $ uid : gm . $ Snterm ( $ uid : gm . $ Entry . obj ( $ n . expr $ : $ uid : gm . $ Entry . t ' $ n . tvar ) ) $ >> ] | TXopt _loc t -> <: expr < $ uid : gm . $ Sopt $ make_expr entry " " t $ >> | TXtry _loc t -> <: expr < $ uid : gm . $ Stry $ make_expr entry " " t $ >> | TXrules _loc rl -> <: expr < $ uid : gm . $ srules $ entry . expr $ $ make_expr_rules _loc entry rl " " $ >> | TXself _loc -> <: expr < $ uid : gm . $ Sself >> | TXkwd _loc kwd -> <: expr < $ uid : gm . $ Skeyword $ str : kwd $ >> | TXtok _loc match_fun descr -> <: expr < $ uid : gm . $ Stoken ( $ match_fun , $ ` $ str : descr ) $ >> ] and make_expr_rules _loc n rl tvar = List . fold_left ( fun txt ( sl , ac ) -> let sl = List . fold_right ( fun t txt -> let x = make_expr n tvar t in <: expr < [ $ x $ :: $ txt ] $ ) >> sl <: expr < [ ] >> in <: expr < [ ( $ sl , $ $ ac ) $ :: $ txt ] $ ) >> <: expr < [ ] >> rl ; value expr_of_delete_rule _loc n sl = let sl = List . fold_right ( fun s e -> <: expr < [ $ make_expr n " " s . text $ :: $ e ] $ ) >> sl <: expr < [ ] >> in ( <: expr < $ n . expr $ , >> sl ) ; value rec tvar_of_ident = fun [ <: ident < $ lid : x $ >> | <: ident < $ uid : x $ >> -> x | <: ident < $ uid : x . $$ xs $ >> -> x ^ " __ " ^ tvar_of_ident xs | _ -> failwith " internal error in the Grammar extension " ] ; value mk_name _loc i = { expr = <: expr < $ id : i $ ; >> tvar = tvar_of_ident i ; loc = _loc } ; value slist loc min sep symb = TXlist loc min symb sep ; value text_of_entry _loc e = let ent = let x = e . name in let _loc = e . name . loc in <: expr < ( $ x . expr $ : $ uid : gm . $ Entry . t ' $ x . tvar ) $ >> in let pos = match e . pos with [ Some pos -> <: expr < Some $ pos $ >> | None -> <: expr < None >> ] in let txt = List . fold_right ( fun level txt -> let lab = match level . label with [ Some lab -> <: expr < Some $ str : lab $ >> | None -> <: expr < None >> ] in let ass = match level . assoc with [ Some ass -> <: expr < Some $ ass $ >> | None -> <: expr < None >> ] in let txt = let rl = srules _loc e . name . tvar level . rules e . name . tvar in let e = make_expr_rules _loc e . name rl e . name . tvar in <: expr < [ ( $ lab , $ $ ass , $ $ e ) $ :: $ txt ] $ >> in txt ) e . levels <: expr < [ ] >> in ( ent , pos , txt ) ; value let_in_of_extend _loc gram gl el args = match gl with [ None -> args | Some nl -> do { check_use nl el ; let ll = let same_tvar e n = e . name . tvar = n . tvar in List . fold_right ( fun e ll -> match e . name . expr with [ <: expr < $ lid : _ $ >> -> if List . exists ( same_tvar e ) nl then ll else if List . exists ( same_tvar e ) ll then ll else [ e . name :: ll ] | _ -> ll ] ) el [ ] in let local_binding_of_name { expr = e ; tvar = x ; loc = _loc } = let i = match e with [ <: expr < $ lid : i $ >> -> i | _ -> failwith " internal error in the Grammar extension " ] in <: binding < $ lid : i $ = ( grammar_entry_create $ str : i $ : $ uid : gm . $ Entry . t ' $ x ) $ >> in let expr_of_name { expr = e ; tvar = x ; loc = _loc } = <: expr < ( $ e $ : $ uid : gm . $ Entry . t ' $ x ) $ >> in let e = match ll with [ [ ] -> args | [ x :: xs ] -> let locals = List . fold_right ( fun name acc -> <: binding < $ acc $ and $ local_binding_of_name name $ ) >> xs ( local_binding_of_name x ) in let entry_mk = match gram with [ Some g -> <: expr < $ uid : gm . $ Entry . mk $ id : g $ >> | None -> <: expr < $ uid : gm . $ Entry . mk >> ] in <: expr < let grammar_entry_create = $ entry_mk $ in let $ locals $ in $ args $ >> ] in match nl with [ [ ] -> e | [ x :: xs ] -> let globals = List . fold_right ( fun name acc -> <: binding < $ acc $ and _ = $ expr_of_name name $ ) >> xs <: binding < _ = $ expr_of_name x $ >> in <: expr < let $ globals $ in $ e $ >> ] } ] ; class subst gmod = object inherit Ast . map as super ; method ident = fun [ <: ident < $ uid : x $ >> when x = gm -> gmod | x -> super # ident x ] ; end ; value subst_gmod ast gmod = ( new subst gmod ) # expr ast ; value text_of_functorial_extend _loc gmod gram gl el = let args = let el = List . map ( fun e -> let ( ent , pos , txt ) = text_of_entry e . name . loc e in let e = <: expr < $ uid : gm . $ extend $ ent $ ( ( fun ( ) -> ( $ pos , $ $ txt ) ) $ ( ) ) >> in if split_ext . val then <: expr < let aux ( ) = $ e $ in aux ( ) >> else e ) el in match el with [ [ ] -> <: expr < ( ) >> | [ e ] -> e | [ e :: el ] -> <: expr < do { $ List . fold_left ( fun acc x -> <: expr < $ acc ; $ $ x $ ) >> e el $ } >> ] in subst_gmod ( let_in_of_extend _loc gram gl el args ) gmod ; value wildcarder = object ( self ) inherit Ast . map as super ; method patt = fun [ <: patt @ _loc < $ lid : _ $ >> -> <: patt < _ >> | <: patt < ( $ p $ as $ _ ) $ >> -> self # patt p | p -> super # patt p ] ; end ; value mk_tok _loc p t = let p ' = wildcarder # patt p in let match_fun = if Ast . is_irrefut_patt p ' then <: expr < fun [ $ pat : p ' $ -> True ] >> else <: expr < fun [ $ pat : p ' $ -> True | _ -> False ] >> in let descr = string_of_patt p ' in let text = TXtok _loc match_fun descr in { used = [ ] ; text = text ; styp = t ; pattern = Some p } ; value symbol = Gram . Entry . mk " symbol " ; value check_not_tok s = match s with [ { text = TXtok _loc _ _ } -> Loc . raise _loc ( Stream . Error ( " Deprecated syntax , use a sub rule . " ^ " LIST0 STRING becomes LIST0 [ x = STRING -> x ] " ) ) | _ -> ( ) ] ; Camlp4_config . antiquotations . val := True ; EXTEND Gram GLOBAL : expr symbol ; expr : AFTER " top " [ [ " EXTEND " ; e = extend_body ; " END " -> e | " DELETE_RULE " ; e = delete_rule_body ; " END " -> e | " GDELETE_RULE " -> Loc . raise _loc ( Stream . Error " Deprecated syntax , use DELETE_RULE MyGramModule . . . END instead " ) | " GEXTEND " -> Loc . raise _loc ( Stream . Error " Deprecated syntax , use EXTEND MyGramModule . . . END instead " ) ] ] ; extend_header : [ [ " ( " ; i = qualid ; " " ; : t = t_qualid ; " ) " -> ( Some i , t ) | g = qualuid -> ( None , g ) ] ] ; extend_body : [ [ ( gram , g ) = extend_header ; global_list = OPT global ; el = LIST1 [ e = entry ; semi_sep -> e ] -> text_of_functorial_extend _loc g gram global_list el ] ] ; delete_rule_body : [ [ g = qualuid ; n = name ; " " ; : sl = LIST0 symbol SEP semi_sep -> let ( e , b ) = expr_of_delete_rule _loc n sl in subst_gmod <: expr < $ uid : gm . $ delete_rule $ e $ $ b $ >> g ] ] ; qualuid : [ [ [ LIDENT | UIDENT " GLOBAL " ] -> Loc . raise _loc ( Stream . Error " Deprecated syntax , the grammar module is expected " ) ] | [ x = UIDENT ; " . " ; xs = SELF -> <: ident < $ uid : x . $$ xs $ >> | i = UIDENT -> <: ident < $ uid : i $ >> ] ] ; qualuid : [ [ [ LIDENT | UIDENT " GLOBAL " ] -> Loc . raise _loc ( Stream . Error " Deprecated syntax , the grammar module is expected " ) ] | [ x = UIDENT ; " . " ; xs = SELF -> <: ident < $ uid : x . $$ xs $ >> | i = UIDENT -> <: ident < $ uid : i $ >> ] ] ; qualid : [ [ x = UIDENT ; " . " ; xs = SELF -> <: ident < $ uid : x . $$ xs $ >> | i = UIDENT -> <: ident < $ uid : i $ >> | i = LIDENT -> <: ident < $ lid : i $ >> ] ] ; t_qualid : [ [ x = UIDENT ; " . " ; xs = SELF -> <: ident < $ uid : x . $$ xs $ >> | x = UIDENT ; " . " ; ` LIDENT " t " -> <: ident < $ uid : x $ >> | ` ( LIDENT _ | UIDENT _ ) -> Loc . raise _loc ( Stream . Error ( " Wrong EXTEND header , the grammar type must finish by ' t ' , " ^ " like in EXTEND ( g : Gram . t ) . . . END " ) ) ] ] ; global : [ [ UIDENT " GLOBAL " ; " " ; : sl = LIST1 name ; semi_sep -> sl ] ] ; entry : [ [ n = name ; " " ; : pos = OPT position ; ll = level_list -> { name = n ; pos = pos ; levels = ll } ] ] ; position : [ [ UIDENT " FIRST " -> <: expr < Camlp4 . Sig . Grammar . First >> | UIDENT " LAST " -> <: expr < Camlp4 . Sig . Grammar . Last >> | UIDENT " BEFORE " ; n = string -> <: expr < Camlp4 . Sig . Grammar . Before $ n $ >> | UIDENT " AFTER " ; n = string -> <: expr < Camlp4 . Sig . Grammar . After $ n $ >> | UIDENT " LEVEL " ; n = string -> <: expr < Camlp4 . Sig . Grammar . Level $ n $ >> ] ] ; level_list : [ [ " [ " ; ll = LIST0 level SEP " " ; | " ] " -> ll ] ] ; level : [ [ lab = OPT [ x = STRING -> x ] ; ass = OPT assoc ; rules = rule_list -> { label = lab ; assoc = ass ; rules = rules } ] ] ; assoc : [ [ UIDENT " LEFTA " -> <: expr < Camlp4 . Sig . Grammar . LeftA >> | UIDENT " RIGHTA " -> <: expr < Camlp4 . Sig . Grammar . RightA >> | UIDENT " NONA " -> <: expr < Camlp4 . Sig . Grammar . NonA >> ] ] ; rule_list : [ [ " [ " ; " ] " -> [ ] | " [ " ; rules = LIST1 rule SEP " " ; | " ] " -> retype_rule_list_without_patterns _loc rules ] ] ; rule : [ [ psl = LIST0 psymbol SEP semi_sep ; " " ; -> act = expr -> { prod = psl ; action = Some act } | psl = LIST0 psymbol SEP semi_sep -> { prod = psl ; action = None } ] ] ; psymbol : [ [ p = LIDENT ; " " ; = s = symbol -> match s . pattern with [ Some ( <: patt < $ uid : u $ ( $ tup :<: patt < _ ) >>$ >> as p ' ) -> let match_fun = <: expr < fun [ $ pat : p ' $ -> True | _ -> False ] >> in let p ' = <: patt < ( $ p ' $ as $ lid : p ) $ >> in let descr = u ^ " _ " in let text = TXtok _loc match_fun descr in { ( s ) with text = text ; pattern = Some p ' } | _ -> { ( s ) with pattern = Some <: patt < $ lid : p $ >> } ] | i = LIDENT ; lev = OPT [ UIDENT " LEVEL " ; s = STRING -> s ] -> let name = mk_name _loc <: ident < $ lid : i $ >> in let text = TXnterm _loc name lev in let styp = STquo _loc i in { used = [ i ] ; text = text ; styp = styp ; pattern = None } | p = pattern ; " " ; = s = symbol -> match s . pattern with [ Some <: patt < $ uid : u $ ( $ tup :<: patt < _ ) >>$ >> -> mk_tok _loc <: patt < $ uid : u $ $ p $ >> s . styp | _ -> { ( s ) with pattern = Some p } ] | s = symbol -> s ] ] ; symbol : [ " top " NONA [ UIDENT " LIST0 " ; s = SELF ; sep = OPT [ UIDENT " SEP " ; t = symbol -> t ] -> let ( ) = check_not_tok s in 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 ; pattern = None } | UIDENT " LIST1 " ; s = SELF ; sep = OPT [ UIDENT " SEP " ; t = symbol -> t ] -> let ( ) = check_not_tok s in 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 ; pattern = None } | UIDENT " OPT " ; s = SELF -> let ( ) = check_not_tok s in let styp = STapp _loc ( STlid _loc " option " ) s . styp in let text = TXopt _loc s . text in { used = s . used ; text = text ; styp = styp ; pattern = None } | UIDENT " TRY " ; s = SELF -> let text = TXtry _loc s . text in { used = s . used ; text = text ; styp = s . styp ; pattern = None } ] | [ UIDENT " SELF " -> { used = [ ] ; text = TXself _loc ; styp = STself _loc " SELF " ; pattern = None } | UIDENT " NEXT " -> { used = [ ] ; text = TXnext _loc ; styp = STself _loc " NEXT " ; pattern = None } | " [ " ; rl = LIST0 rule SEP " " ; | " ] " -> let rl = retype_rule_list_without_patterns _loc rl in let t = new_type_var ( ) in { used = used_of_rule_list rl ; text = TXrules _loc ( srules _loc t rl " " ) ; styp = STquo _loc t ; pattern = None } | " ` " ; p = patt -> mk_tok _loc p ( STtok _loc ) | x = UIDENT -> mk_tok _loc <: patt < $ uid : x $ ( $ tup :<: patt < _ ) >>$ >> ( STstring_tok _loc ) | x = UIDENT ; s = STRING -> mk_tok _loc <: patt < $ uid : x $ $ str : s $ >> ( STtok _loc ) | x = UIDENT ; ` ANTIQUOT " " s -> let e = AntiquotSyntax . parse_expr _loc s in let match_fun = <: expr < fun [ $ uid : x $ camlp4_x when camlp4_x = $ e $ -> True | _ -> False ] >> in let descr = " " $ ^ x ^ " " ^ s in let text = TXtok _loc match_fun descr in let p = <: patt < $ uid : x $ ( $ tup :<: patt < _ ) >>$ >> in { used = [ ] ; text = text ; styp = STtok _loc ; pattern = Some p } | s = STRING -> { used = [ ] ; text = TXkwd _loc s ; styp = STtok _loc ; pattern = None } | i = UIDENT ; " . " ; il = qualid ; lev = OPT [ UIDENT " LEVEL " ; s = STRING -> s ] -> let n = mk_name _loc <: ident < $ uid : i . $$ il $ >> in { used = [ n . tvar ] ; text = TXnterm _loc n lev ; styp = STquo _loc n . tvar ; pattern = None } | n = name ; lev = OPT [ UIDENT " LEVEL " ; s = STRING -> s ] -> { used = [ n . tvar ] ; text = TXnterm _loc n lev ; styp = STquo _loc n . tvar ; pattern = None } | " ( " ; s_t = SELF ; " ) " -> s_t ] ] ; pattern : [ [ i = LIDENT -> <: patt < $ lid : i $ >> | " _ " -> <: patt < _ >> | " ( " ; p = pattern ; " ) " -> <: patt < $ p $ >> | " ( " ; p1 = pattern ; " , " ; p2 = comma_patt ; " ) " -> <: patt < ( $ p1 , $ $ p2 $ ) >> ] ] ; comma_patt : [ [ p1 = SELF ; " , " ; p2 = SELF -> <: patt < $ p1 , $ $ p2 $ >> | p = pattern -> p ] ] ; name : [ [ il = qualid -> mk_name _loc il ] ] ; string : [ [ s = STRING -> <: expr < $ str : s $ >> | ` ANTIQUOT " " s -> AntiquotSyntax . parse_expr _loc s ] ] ; semi_sep : [ [ " ; " -> ( ) ] ] ; END ; value sfold _loc n foldfun f e s = let styp = STquo _loc ( new_type_var ( ) ) in let e = <: expr < $ uid : gm . $$ lid : foldfun $ $ f $ $ e $ >> in let t = STapp _loc ( STapp _loc ( STtyp <: ctyp < $ uid : gm . $ fold _ ) >> s . styp ) styp in { used = s . used ; text = TXmeta _loc n [ s . text ] e t ; styp = styp ; pattern = None } ; value sfoldsep _loc n foldfun f e s sep = let styp = STquo _loc ( new_type_var ( ) ) in let e = <: expr < $ uid : gm . $$ lid : foldfun $ $ f $ $ e $ >> in let t = STapp _loc ( STapp _loc ( STtyp <: ctyp < $ uid : gm . $ foldsep _ ) >> s . styp ) styp in { used = s . used @ sep . used ; text = TXmeta _loc n [ s . text ; sep . text ] e t ; styp = styp ; pattern = None } ; EXTEND Gram GLOBAL : symbol ; symbol : LEVEL " top " [ [ UIDENT " FOLD0 " ; f = simple_expr ; e = simple_expr ; s = SELF -> sfold _loc " FOLD0 " " sfold0 " f e s | UIDENT " FOLD1 " ; f = simple_expr ; e = simple_expr ; s = SELF -> sfold _loc " FOLD1 " " sfold1 " f e s | UIDENT " FOLD0 " ; f = simple_expr ; e = simple_expr ; s = SELF ; UIDENT " SEP " ; sep = symbol -> sfoldsep _loc " FOLD0 SEP " " sfold0sep " f e s sep | UIDENT " FOLD1 " ; f = simple_expr ; e = simple_expr ; s = SELF ; UIDENT " SEP " ; sep = symbol -> sfoldsep _loc " FOLD1 SEP " " sfold1sep " f e s sep ] ] ; simple_expr : [ [ i = a_LIDENT -> <: expr < $ lid : i $ >> | " ( " ; e = expr ; " ) " -> e ] ] ; END ; Options . add " - split_ext " ( Arg . Set split_ext ) " Split EXTEND by functions to turn around a PowerPC problem . " ; Options . add " - split_gext " ( Arg . Set split_ext ) " Old name for the option - split_ext . " ; Options . add " - meta_action " ( Arg . Set meta_action ) " Undocumented " ; end ; |
module M = Register . OCamlSyntaxExtension Id Make ; |
module Id = struct value name = " Camlp4ListComprehension " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) = struct open Sig ; include Syntax ; value rec loop n = fun [ [ ] -> None | [ ( x , _ ) ] -> if n = 1 then Some x else None | [ _ :: l ] -> loop ( n - 1 ) l ] ; value stream_peek_nth n strm = loop n ( Stream . npeek n strm ) ; value test_patt_lessminus = Gram . Entry . of_parser " test_patt_lessminus " ( fun strm -> let rec skip_patt n = match stream_peek_nth n strm with [ Some ( KEYWORD " " ) <- -> n | Some ( KEYWORD ( " [ " | " [ " ) ) < -> skip_patt ( ignore_upto " ] " ( n + 1 ) + 1 ) | Some ( KEYWORD " ( " ) -> skip_patt ( ignore_upto " ) " ( n + 1 ) + 1 ) | Some ( KEYWORD " { " ) -> skip_patt ( ignore_upto " } " ( n + 1 ) + 1 ) | Some ( KEYWORD ( " as " | " " :: | " , " | " _ " ) ) | Some ( LIDENT _ | UIDENT _ ) -> skip_patt ( n + 1 ) | Some _ | None -> raise Stream . Failure ] and ignore_upto end_kwd n = match stream_peek_nth n strm with [ Some ( KEYWORD prm ) when prm = end_kwd -> n | Some ( KEYWORD ( " [ " | " [ " ) ) < -> ignore_upto end_kwd ( ignore_upto " ] " ( n + 1 ) + 1 ) | Some ( KEYWORD " ( " ) -> ignore_upto end_kwd ( ignore_upto " ) " ( n + 1 ) + 1 ) | Some ( KEYWORD " { " ) -> ignore_upto end_kwd ( ignore_upto " } " ( n + 1 ) + 1 ) | Some _ -> ignore_upto end_kwd ( n + 1 ) | None -> raise Stream . Failure ] in skip_patt 1 ) ; value map _loc p e l = match ( p , e ) with [ ( <: patt < $ lid : x $ , >> <: expr < $ lid : y $ ) >> when x = y -> l | _ -> if Ast . is_irrefut_patt p then <: expr < List . map ( fun $ p $ -> $ e ) $ $ l $ >> else <: expr < List . fold_right ( fun [ $ pat : p $ when True -> ( fun x xs -> [ x :: xs ] ) $ e $ | _ -> ( fun l -> l ) ] ) $ l $ [ ] >> ] ; value filter _loc p b l = if Ast . is_irrefut_patt p then <: expr < List . filter ( fun $ p $ -> $ b ) $ $ l $ >> else <: expr < List . filter ( fun [ $ p $ when True -> $ b $ | _ -> False ] ) $ l $ ; >> value concat _loc l = <: expr < List . concat $ l $ ; >> value rec compr _loc e = fun [ [ ` gen ( p , l ) ] -> map _loc p e l | [ ` gen ( p , l ) ; ` cond b :: items ] -> compr _loc e [ ` gen ( p , filter _loc p b l ) :: items ] | [ ` gen ( p , l ) :: ( [ ` gen ( _ , _ ) :: _ ] as is ) ] -> concat _loc ( map _loc p ( compr _loc e is ) l ) | _ -> raise Stream . Failure ] ; DELETE_RULE Gram expr : " [ " ; sem_expr_for_list ; " ] " END ; value is_revised = try do { DELETE_RULE Gram expr : " [ " ; sem_expr_for_list ; " " ; :: expr ; " ] " END ; True } with [ Not_found -> False ] ; value comprehension_or_sem_expr_for_list = Gram . Entry . mk " comprehension_or_sem_expr_for_list " ; EXTEND Gram GLOBAL : expr comprehension_or_sem_expr_for_list ; expr : LEVEL " simple " [ [ " [ " ; e = comprehension_or_sem_expr_for_list ; " ] " -> e ] ] ; comprehension_or_sem_expr_for_list : [ [ e = expr LEVEL " top " ; " ; " ; mk = sem_expr_for_list -> <: expr < [ $ e $ :: $ mk <: expr < [ ] >>$ ] >> | e = expr LEVEL " top " ; " ; " -> <: expr < [ $ e ] $ >> | e = expr LEVEL " top " ; " " ; | l = LIST1 item SEP " ; " -> compr _loc e l | e = expr LEVEL " top " -> <: expr < [ $ e ] $ >> ] ] ; item : [ [ p = TRY [ p = patt ; " " <- -> p ] ; e = expr LEVEL " top " -> ` gen ( p , e ) | e = expr LEVEL " top " -> ` cond e ] ] ; END ; if is_revised then EXTEND Gram GLOBAL : expr comprehension_or_sem_expr_for_list ; comprehension_or_sem_expr_for_list : [ [ e = expr LEVEL " top " ; " ; " ; mk = sem_expr_for_list ; " " ; :: last = expr -> <: expr < [ $ e $ :: $ mk last $ ] >> | e = expr LEVEL " top " ; " " ; :: last = expr -> <: expr < [ $ e $ :: $ last $ ] >> ] ] ; END else ( ) ; end ; |
let module M = Register . OCamlSyntaxExtension Id Make in ( ) ; |
module Id = struct value name = " Camlp4MacroParser " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) = struct open Sig ; include Syntax ; type item_or_def ' a = [ SdStr of ' a | SdDef of string and option ( list string * Ast . expr ) | SdUnd of string | SdITE of bool and list ( item_or_def ' a ) and list ( item_or_def ' a ) | SdLazy of Lazy . t ' a ] ; value rec list_remove x = fun [ [ ( y , _ ) :: l ] when y = x -> l | [ d :: l ] -> [ d :: list_remove x l ] | [ ] -> [ ] ] ; value defined = ref [ ] ; value is_defined i = List . mem_assoc i defined . val ; value bad_patt _loc = Loc . raise _loc ( Failure " this macro cannot be used in a pattern ( see its definition ) " ) ; value substp _loc env = loop where rec loop = fun [ <: expr < $ e1 $ $ e2 $ >> -> <: patt < $ loop e1 $ $ loop e2 $ >> | <: expr < >> -> <: patt < >> | <: expr < $ lid : x $ >> -> try List . assoc x env with [ Not_found -> <: patt < $ lid : x $ >> ] | <: expr < $ uid : x $ >> -> try List . assoc x env with [ Not_found -> <: patt < $ uid : x $ >> ] | <: expr < $ int : x $ >> -> <: patt < $ int : x $ >> | <: expr < $ str : s $ >> -> <: patt < $ str : s $ >> | <: expr < ( $ tup : x ) $ >> -> <: patt < ( $ tup : loop x ) $ >> | <: expr < $ x1 , $ $ x2 $ >> -> <: patt < $ loop x1 , $ $ loop x2 $ >> | <: expr < { $ bi $ } >> -> let rec substbi = fun [ <: rec_binding < $ b1 ; $ $ b2 $ >> -> <: patt < $ substbi b1 ; $ $ substbi b2 $ >> | <: rec_binding < $ i $ = $ e $ >> -> <: patt < $ i $ = $ loop e $ >> | _ -> bad_patt _loc ] in <: patt < { $ substbi bi $ } >> | _ -> bad_patt _loc ] ; class reloc _loc = object inherit Ast . map as super ; method loc _ = _loc ; end ; class subst _loc env = object inherit reloc _loc as super ; method expr = fun [ <: expr < $ lid : x $ >> | <: expr < $ uid : x $ >> as e -> try List . assoc x env with [ Not_found -> super # expr e ] | e -> super # expr e ] ; method patt = fun [ <: patt < $ lid : x $ >> | <: patt < $ uid : x $ >> as p -> try substp _loc [ ] ( List . assoc x env ) with [ Not_found -> super # patt p ] | p -> super # patt p ] ; end ; value incorrect_number loc l1 l2 = Loc . raise loc ( Failure ( Printf . sprintf " expected % d parameters ; found % d " ( List . length l2 ) ( List . length l1 ) ) ) ; value define eo x = do { match eo with [ Some ( [ ] , e ) -> EXTEND Gram expr : LEVEL " simple " [ [ UIDENT $ x $ -> ( new reloc _loc ) # expr e ] ] ; patt : LEVEL " simple " [ [ UIDENT $ x $ -> let p = substp _loc [ ] e in ( new reloc _loc ) # patt p ] ] ; END | Some ( sl , e ) -> EXTEND Gram expr : LEVEL " apply " [ [ UIDENT $ x ; $ param = SELF -> let el = match param with [ <: expr < ( $ tup : e ) $ >> -> Ast . list_of_expr e [ ] | e -> [ e ] ] in if List . length el = List . length sl then let env = List . combine sl el in ( new subst _loc env ) # expr e else incorrect_number _loc el sl ] ] ; patt : LEVEL " simple " [ [ UIDENT $ x ; $ param = SELF -> let pl = match param with [ <: patt < ( $ tup : p ) $ >> -> Ast . list_of_patt p [ ] | p -> [ p ] ] in if List . length pl = List . length sl then let env = List . combine sl pl in let p = substp _loc env e in ( new reloc _loc ) # patt p else incorrect_number _loc pl sl ] ] ; END | None -> ( ) ] ; defined . val := [ ( x , eo ) :: defined . val ] ; } ; value undef x = try do { let eo = List . assoc x defined . val in match eo with [ Some ( [ ] , _ ) -> do { DELETE_RULE Gram expr : UIDENT $ x $ END ; DELETE_RULE Gram patt : UIDENT $ x $ END ; } | Some ( _ , _ ) -> do { DELETE_RULE Gram expr : UIDENT $ x ; $ SELF END ; DELETE_RULE Gram patt : UIDENT $ x ; $ SELF END ; } | None -> ( ) ] ; defined . val := list_remove x defined . val ; } with [ Not_found -> ( ) ] ; value parse_def s = match Gram . parse_string expr ( Loc . mk " < command line " ) > s with [ <: expr < $ uid : n $ >> -> define None n | <: expr < $ uid : n $ = $ e $ >> -> define ( Some ( [ ] , e ) ) n | _ -> invalid_arg s ] ; value include_dirs = ref [ ] ; value add_include_dir str = if str <> " " then let str = if String . get str ( ( String . length str ) - 1 ) = ' ' / then str else str ^ " " / in include_dirs . val := include_dirs . val @ [ str ] else ( ) ; value parse_include_file rule = let dir_ok file dir = Sys . file_exists ( dir ^ file ) in fun file -> let file = try ( List . find ( dir_ok file ) ( include_dirs . val @ [ " . " ] ) ) / ^ file with [ Not_found -> file ] in let ch = open_in file in let st = Stream . of_channel ch in Gram . parse rule ( Loc . mk file ) st ; value rec execute_macro nil cons = fun [ SdStr i -> i | SdDef x eo -> do { define eo x ; nil } | SdUnd x -> do { undef x ; nil } | SdITE b l1 l2 -> execute_macro_list nil cons ( if b then l1 else l2 ) | SdLazy l -> Lazy . force l ] and execute_macro_list nil cons = fun [ [ ] -> nil | [ hd :: tl ] -> let il1 = execute_macro nil cons hd in let il2 = execute_macro_list nil cons tl in cons il1 il2 ] ; value stack = Stack . create ( ) ; value make_SdITE_result st1 st2 = let test = Stack . pop stack in SdITE test st1 st2 ; type branch = [ Then | Else ] ; value execute_macro_if_active_branch _loc nil cons branch macro_def = let test = Stack . top stack in let item = if ( test && branch = Then ) || ( ( not test ) && branch = Else ) then execute_macro nil cons macro_def else nil in SdStr ( item ) ; EXTEND Gram GLOBAL : expr patt str_item sig_item ; str_item : FIRST [ [ x = macro_def -> execute_macro <: str_item <>> ( fun a b -> <: str_item < $ a ; $ $ b $ ) >> x ] ] ; sig_item : FIRST [ [ x = macro_def_sig -> execute_macro <: sig_item <>> ( fun a b -> <: sig_item < $ a ; $ $ b $ ) >> x ] ] ; macro_def : [ [ " DEFINE " ; i = uident ; def = opt_macro_value -> SdDef i def | " UNDEF " ; i = uident -> SdUnd i | " IFDEF " ; uident_eval_ifdef ; " THEN " ; st1 = smlist_then ; st2 = else_macro_def -> make_SdITE_result st1 st2 | " IFNDEF " ; uident_eval_ifndef ; " THEN " ; st1 = smlist_then ; st2 = else_macro_def -> make_SdITE_result st1 st2 | " INCLUDE " ; fname = STRING -> SdLazy ( lazy ( parse_include_file str_items fname ) ) ] ] ; macro_def_sig : [ [ " DEFINE " ; i = uident -> SdDef i None | " UNDEF " ; i = uident -> SdUnd i | " IFDEF " ; uident_eval_ifdef ; " THEN " ; sg1 = sglist_then ; sg2 = else_macro_def_sig -> make_SdITE_result sg1 sg2 | " IFNDEF " ; uident_eval_ifndef ; " THEN " ; sg1 = sglist_then ; sg2 = else_macro_def_sig -> make_SdITE_result sg1 sg2 | " INCLUDE " ; fname = STRING -> SdLazy ( lazy ( parse_include_file sig_items fname ) ) ] ] ; uident_eval_ifdef : [ [ i = uident -> Stack . push ( is_defined i ) stack ] ] ; uident_eval_ifndef : [ [ i = uident -> Stack . push ( not ( is_defined i ) ) stack ] ] ; else_macro_def : [ [ " ELSE " ; st = smlist_else ; endif -> st | endif -> [ ] ] ] ; else_macro_def_sig : [ [ " ELSE " ; st = sglist_else ; endif -> st | endif -> [ ] ] ] ; else_expr : [ [ " ELSE " ; e = expr ; endif -> e | endif -> <: expr < ( ) >> ] ] ; smlist_then : [ [ sml = LIST1 [ d = macro_def ; semi -> execute_macro_if_active_branch _loc <: str_item <>> ( fun a b -> <: str_item < $ a ; $ $ b $ ) >> Then d | si = str_item ; semi -> SdStr si ] -> sml ] ] ; smlist_else : [ [ sml = LIST1 [ d = macro_def ; semi -> execute_macro_if_active_branch _loc <: str_item <>> ( fun a b -> <: str_item < $ a ; $ $ b $ ) >> Else d | si = str_item ; semi -> SdStr si ] -> sml ] ] ; sglist_then : [ [ sgl = LIST1 [ d = macro_def_sig ; semi -> execute_macro_if_active_branch _loc <: sig_item <>> ( fun a b -> <: sig_item < $ a ; $ $ b $ ) >> Then d | si = sig_item ; semi -> SdStr si ] -> sgl ] ] ; sglist_else : [ [ sgl = LIST1 [ d = macro_def_sig ; semi -> execute_macro_if_active_branch _loc <: sig_item <>> ( fun a b -> <: sig_item < $ a ; $ $ b $ ) >> Else d | si = sig_item ; semi -> SdStr si ] -> sgl ] ] ; endif : [ [ " END " -> ( ) | " ENDIF " -> ( ) ] ] ; opt_macro_value : [ [ " ( " ; pl = LIST1 [ x = LIDENT -> x ] SEP " , " ; " ) " ; " " ; = e = expr -> Some ( pl , e ) | " " ; = e = expr -> Some ( [ ] , e ) | -> None ] ] ; expr : LEVEL " top " [ [ " IFDEF " ; i = uident ; " THEN " ; e1 = expr ; e2 = else_expr -> if is_defined i then e1 else e2 | " IFNDEF " ; i = uident ; " THEN " ; e1 = expr ; e2 = else_expr -> if is_defined i then e2 else e1 | " DEFINE " ; i = LIDENT ; " " ; = def = expr ; " IN " ; body = expr -> ( new subst _loc [ ( i , def ) ] ) # expr body ] ] ; expr : LEVEL " simple " [ [ LIDENT " __FILE__ " -> <: expr < ` $ str : Loc . file_name _loc $ >> | LIDENT " __LOCATION__ " -> let ( a , b , c , d , e , f , g , h ) = Loc . to_tuple _loc in <: expr < Loc . of_tuple ( ` $ str : a , $ ` $ int : b , $ ` $ int : c , $ ` $ int : d , $ ` $ int : e , $ ` $ int : f , $ ` $ int : g , $ $ if h then <: expr < True >> else <: expr < False >> ) $ >> ] ] ; patt : [ [ " IFDEF " ; i = uident ; " THEN " ; p1 = patt ; " ELSE " ; p2 = patt ; endif -> if is_defined i then p1 else p2 | " IFNDEF " ; i = uident ; " THEN " ; p1 = patt ; " ELSE " ; p2 = patt ; endif -> if is_defined i then p2 else p1 ] ] ; uident : [ [ i = UIDENT -> i ] ] ; expr : BEFORE " simple " [ [ " ` " ; kwd = [ " IFDEF " | " IFNDEF " | " THEN " | " ELSE " | " END " | " ENDIF " | " DEFINE " | " IN " ] -> <: expr < ` $ uid : kwd $ >> | " ` " ; s = a_ident -> <: expr < ` $ s $ >> ] ] ; patt : BEFORE " simple " [ [ " ` " ; kwd = [ " IFDEF " | " IFNDEF " | " THEN " | " ELSE " | " END " | " ENDIF " ] -> <: patt < ` $ uid : kwd $ >> | " ` " ; s = a_ident -> <: patt < ` $ s $ >> ] ] ; END ; Options . add " - D " ( Arg . String parse_def ) " < string > Define for IFDEF instruction . " ; Options . add " - U " ( Arg . String undef ) " < string > Undefine for IFDEF instruction . " ; Options . add " - I " ( Arg . String add_include_dir ) " < string > Add a directory to INCLUDE search path . " ; end ; |
let module M = Register . OCamlSyntaxExtension Id Make in ( ) ; |
module MakeNothing ( AstFilters : Camlp4 . Sig . AstFilters ) = struct open AstFilters ; open Ast ; value remove_nothings = fun [ <: expr < $ e $ NOTHING >> | <: expr < fun $ <: patt < NOTHING >> $ -> $ e $ >> -> e | e -> e ] ; register_str_item_filter ( Ast . map_expr remove_nothings ) # str_item ; end ; |
let module M = Camlp4 . Register . AstFilter Id MakeNothing in ( ) ; |
module MapTy = Map . Make String ; |
type t = { name : Ast . ident ; type_decls : MapTy . t Ast . ctyp ; acc : Ast . expr ; app : Ast . expr ; id : Ast . expr ; tup : Ast . expr ; com : Ast . expr ; str : Ast . expr ; int : Ast . expr ; flo : Ast . expr ; chr : Ast . expr ; ant : Ast . ident ; } ; fun [ <: ident < $ lid : s $ >> -> s | <: ident < $ uid : s $ >> -> s | <: ident < $ i1 . $$ i2 $ >> -> " acc_ " ^ ( string_of_ident i1 ) ^ " _ " ^ ( string_of_ident i2 ) | <: ident < $ i1 $ $ i2 $ >> -> " app_ " ^ ( string_of_ident i1 ) ^ " _ " ^ ( string_of_ident i2 ) | <: ident < $ anti : _ $ >> -> assert False ] ; let ( _ , res ) = List . fold_left begin fun ( i , acc ) ty -> ( succ i , f ty i acc ) end ( 0 , init ) ty in res ; let rec loop acc t = match t with [ <: ctyp < $ uid : cons $ of $ ty $ >> -> f cons ( Ast . list_of_ctyp ty [ ] ) acc | <: ctyp < $ uid : cons $ >> -> f cons [ ] acc | <: ctyp < $ t1 $ | $ t2 $ >> -> loop ( loop acc t1 ) t2 | <: ctyp <>> -> acc | _ -> assert False ] in loop init ty ; MapTy . fold f m . type_decls init ; fold_args tyargs begin fun _ i acc -> <: patt < $ acc $ $ id : x i $ >> end <: patt < $ id : cons $ ; >> fold_args tyargs begin fun _ i acc -> <: expr < $ acc $ $ id : x i $ >> end <: expr < $ id : cons $ ; >> let ls = String . length s in ls > 3 && String . sub s ( ls - 3 ) 3 = " Ant " ; fun [ <: ident < $ i1 . $$ i2 $ >> -> <: expr < Ast . IdAcc _loc $ meta_ident m i1 $ $ meta_ident m i2 $ >> | <: ident < $ i1 $ $ i2 $ >> -> <: expr < Ast . IdApp _loc $ meta_ident m i1 $ $ meta_ident m i2 $ >> | <: ident < $ anti : s $ >> -> <: expr < $ anti : s $ >> | <: ident < $ lid : s $ >> -> <: expr < Ast . IdLid _loc $ str : s $ >> | <: ident < $ uid : s $ >> -> <: expr < Ast . IdUid _loc $ str : s $ >> ] ; let m_name_uid x = <: ident < $ m . name . $$ uid : x $ >> in fold_type_decls m begin fun tyname tydcl binding_acc -> match tydcl with [ Ast . TyDcl _ _ tyvars <: ctyp < [ $ ty ] $ >> _ -> let match_case = fold_data_ctors ty begin fun cons tyargs acc -> let m_name_cons = m_name_uid cons in let init = m_id m ( meta_ident m m_name_cons ) in let p = patt_of_data_ctor_decl m_name_cons tyargs in let e = if List . mem cons [ " BAnt " ; " OAnt " ; " LAnt " ; " ReAnt " ; " DiAnt " ; " MuAnt " ; " PrAnt " ; " ViAnt " ; " OvAnt " ; " RvAnt " ] then <: expr < $ id : m . ant $ _loc x0 >> else if is_antiquot_data_ctor cons then expr_of_data_ctor_decl m . ant tyargs else fold_args tyargs begin fun ty i acc -> let rec fcall_of_ctyp ty = match ty with [ <: ctyp < $ id : id $ >> -> <: expr < $ id : meta_ ( string_of_ident id ) $ >> | <: ctyp < ( $ t1 $ * $ t2 ) $ >> -> <: expr < fun _loc ( x1 , x2 ) -> $ m . tup $ _loc ( $ m . com $ _loc ( $ fcall_of_ctyp t1 $ _loc x1 ) ( $ fcall_of_ctyp t2 $ _loc x2 ) ) >> | <: ctyp < $ t1 $ $ t2 $ >> -> <: expr < $ fcall_of_ctyp t1 $ $ fcall_of_ctyp t2 $ >> | <: ctyp < ' $ s $ >> -> <: expr < $ lid : mf_ s $ >> | _ -> failure ] in m_app m acc <: expr < $ fcall_of_ctyp ty $ _loc $ id : x i $ >> end init in <: match_case < $ p $ -> $ e $ | $ acc $ >> end <: match_case <>> in let funct = List . fold_right begin fun tyvar acc -> match tyvar with [ <: ctyp < ' +$ s $ >> | <: ctyp < ' -$ s $ >> | <: ctyp < ' $ s $ >> -> <: expr < fun $ lid : mf_ s $ -> $ acc $ >> | _ -> assert False ] end tyvars <: expr < fun _loc -> fun [ $ match_case $ ] >> in <: binding < $ binding_acc $ and $ lid " : meta_ " ^ tyname $ = $ funct $ >> | Ast . TyDcl _ _ _ _ _ -> binding_acc | _ -> assert False ] end <: binding ; <>> inherit Ast . fold as super ; value accu = MapTy . empty ; method get = accu ; method ctyp = fun [ Ast . TyDcl _ name _ _ _ as t -> { < accu = MapTy . add name t accu } > | t -> super # ctyp t ] ; end ; let type_decls = lazy ( find_type_decls # str_item st ) # get in object inherit Ast . map as super ; method module_expr me = let mk_meta_module m = let bi = mk_meta m in <: module_expr < struct value meta_string _loc s = $ m . str $ _loc s ; value meta_int _loc s = $ m . int $ _loc s ; value meta_float _loc s = $ m . flo $ _loc s ; value meta_char _loc s = $ m . chr $ _loc s ; value meta_bool _loc = fun [ False -> $ m_uid m " False " $ | True -> $ m_uid m " True " $ ] ; value rec meta_list mf_a _loc = fun [ [ ] -> $ m_uid m " [ ] " $ | [ x :: xs ] -> $ m_app m ( m_app m ( m_uid m " " ) :: <: expr < mf_a _loc x ) >> <: expr < meta_list mf_a _loc xs >>$ ] ; value rec $ bi ; $ end >> in match super # module_expr me with [ <: module_expr < Camlp4Filters . MetaGeneratorExpr $ id : i $ >> -> mk_meta_module { name = i ; type_decls = Lazy . force type_decls ; app = <: expr < Ast . ExApp ; >> acc = <: expr < Ast . ExAcc ; >> id = <: expr < Ast . ExId ; >> tup = <: expr < Ast . ExTup ; >> com = <: expr < Ast . ExCom ; >> str = <: expr < Ast . ExStr ; >> int = <: expr < Ast . ExInt ; >> flo = <: expr < Ast . ExFlo ; >> chr = <: expr < Ast . ExChr ; >> ant = <: ident < Ast . ExAnt >> } | <: module_expr < Camlp4Filters . MetaGeneratorPatt $ id : i $ >> -> mk_meta_module { name = i ; type_decls = Lazy . force type_decls ; app = <: expr < Ast . PaApp ; >> acc = <: expr < Ast . PaAcc ; >> id = <: expr < Ast . PaId ; >> tup = <: expr < Ast . PaTup ; >> com = <: expr < Ast . PaCom ; >> str = <: expr < Ast . PaStr ; >> int = <: expr < Ast . PaInt ; >> flo = <: expr < Ast . PaFlo ; >> chr = <: expr < Ast . PaChr ; >> ant = <: ident < Ast . PaAnt >> } | me -> me ] ; end # str_item st ; |
module Id : Sig . Id = struct value name = " Camlp4OCamlParser " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) = struct open Sig ; include Syntax ; Camlp4_config . constructors_arity . val := False ; value bigarray_set _loc var newval = match var with [ <: expr < Bigarray . Array1 . get $ arr $ $ c1 $ >> -> Some <: expr < Bigarray . Array1 . set $ arr $ $ c1 $ $ newval $ >> | <: expr < Bigarray . Array2 . get $ arr $ $ c1 $ $ c2 $ >> -> Some <: expr < Bigarray . Array2 . set $ arr $ $ c1 $ $ c2 $ $ newval $ >> | <: expr < Bigarray . Array3 . get $ arr $ $ c1 $ $ c2 $ $ c3 $ >> -> Some <: expr < Bigarray . Array3 . set $ arr $ $ c1 $ $ c2 $ $ c3 $ $ newval $ >> | <: expr < Bigarray . Genarray . get $ arr $ [ | $ coords $ ] | >> -> Some <: expr < Bigarray . Genarray . set $ arr $ [ | $ coords $ ] | $ newval $ >> | _ -> None ] ; value mk_anti ( ? c = " " ) n s = " " \\$^ n ^ c " " ^:^ s ; value conc_seq e1 e2 = match ( e1 , e2 ) with [ ( <: expr @ _loc < do { $ e1 $ } , >> <: expr < do { $ e2 $ } ) >> -> <: expr < do { $ e1 ; $ $ e2 $ } >> | ( <: expr @ _loc < do { $ e1 $ } , >> _ ) -> <: expr < do { $ e1 ; $ $ e2 $ } >> | ( _ , <: expr @ _loc < do { $ e2 $ } ) >> -> <: expr < do { $ e1 ; $ $ e2 $ } >> | _ -> let _loc = Loc . merge ( Ast . loc_of_expr e1 ) ( Ast . loc_of_expr e2 ) in <: expr < do { $ e1 ; $ $ e2 $ } >> ] ; value stream_peek_nth n strm = loop n ( Stream . npeek n strm ) where rec loop n = fun [ [ ] -> None | [ ( x , _ ) ] -> if n == 1 then Some x else None | [ _ :: l ] -> loop ( n - 1 ) l ] ; value test_not_dot_nor_lparen = Gram . Entry . of_parser " test_not_dot_nor_lparen " ( fun strm -> match Stream . peek strm with [ Some ( KEYWORD ( " . " " ( " ) , | _ ) -> raise Stream . Failure | _ -> ( ) ] ) ; value test_ctyp_minusgreater = Gram . Entry . of_parser " test_ctyp_minusgreater " ( fun strm -> let rec skip_simple_ctyp n = match stream_peek_nth n strm with [ Some ( KEYWORD " " ) -> -> n | Some ( KEYWORD ( " [ " | " [ " ) ) < -> skip_simple_ctyp ( ignore_upto " ] " ( n + 1 ) + 1 ) | Some ( KEYWORD " ( " ) -> skip_simple_ctyp ( ignore_upto " ) " ( n + 1 ) + 1 ) | Some ( KEYWORD ( " as " | " ' " | " " : | " " * | " . " | " " # | " " < | " " > | " . . " | " ; " | " _ " | " " ) ) ? -> skip_simple_ctyp ( n + 1 ) | Some ( LIDENT _ | UIDENT _ ) -> skip_simple_ctyp ( n + 1 ) | Some _ | None -> raise Stream . Failure ] and ignore_upto end_kwd n = match stream_peek_nth n strm with [ Some ( KEYWORD prm ) when prm = end_kwd -> n | Some ( KEYWORD ( " [ " | " [ " ) ) < -> ignore_upto end_kwd ( ignore_upto " ] " ( n + 1 ) + 1 ) | Some ( KEYWORD " ( " ) -> ignore_upto end_kwd ( ignore_upto " ) " ( n + 1 ) + 1 ) | Some _ -> ignore_upto end_kwd ( n + 1 ) | None -> raise Stream . Failure ] in match Stream . peek strm with [ Some ( ( KEYWORD " [ " | LIDENT _ | UIDENT _ ) , _ ) -> skip_simple_ctyp 1 | Some ( KEYWORD " object " , _ ) -> raise Stream . Failure | _ -> 1 ] ) ; value lident_colon = Gram . Entry . of_parser " lident_colon " ( fun strm -> match Stream . npeek 2 strm with [ [ ( LIDENT i , _ ) ; ( KEYWORD " " , : _ ) ] -> do { Stream . junk strm ; Stream . junk strm ; i } | _ -> raise Stream . Failure ] ) ; value rec is_ident_constr_call = fun [ <: ident < $ uid : _ $ >> -> True | <: ident < $ _ . $$ i $ >> -> is_ident_constr_call i | _ -> False ] ; value rec is_expr_constr_call = fun [ <: expr < $ id : i $ >> -> is_ident_constr_call i | <: expr < ` $ _ $ >> -> True | <: expr < $ _ . $$ e $ >> -> is_expr_constr_call e | <: expr @ _loc < $ e $ $ _ $ >> -> let res = is_expr_constr_call e in if ( not Camlp4_config . constructors_arity . val ) && res then Loc . raise _loc ( Stream . Error " currified constructor " ) else res | _ -> False ] ; DELETE_RULE Gram expr : SELF ; " where " ; opt_rec ; let_binding END ; DELETE_RULE Gram value_let : " value " END ; DELETE_RULE Gram value_val : " value " END ; DELETE_RULE Gram str_item : value_let ; opt_rec ; binding END ; DELETE_RULE Gram module_type : " ' " ; a_ident END ; DELETE_RULE Gram module_type : SELF ; SELF ; dummy END ; DELETE_RULE Gram module_type : SELF ; " . " ; SELF END ; DELETE_RULE Gram label_expr : label_longident ; fun_binding END ; DELETE_RULE Gram meth_list : meth_decl ; opt_dot_dot END ; DELETE_RULE Gram expr : " let " ; opt_rec ; binding ; " in " ; SELF END ; DELETE_RULE Gram expr : " let " ; " module " ; a_UIDENT ; module_binding0 ; " in " ; SELF END ; DELETE_RULE Gram expr : " let " ; " open " ; module_longident ; " in " ; SELF END ; DELETE_RULE Gram expr : " fun " ; " [ " ; LIST0 match_case0 SEP " " ; | " ] " END ; DELETE_RULE Gram expr : " if " ; SELF ; " then " ; SELF ; " else " ; SELF END ; DELETE_RULE Gram expr : " do " ; do_sequence END ; DELETE_RULE Gram expr : SELF ; SELF END ; DELETE_RULE Gram expr : " new " ; class_longident END ; DELETE_RULE Gram expr : " [ " ; sem_expr_for_list ; " " ; :: expr ; " ] " END ; DELETE_RULE Gram expr : " { " ; label_expr_list ; " } " END ; DELETE_RULE Gram expr : " { " ; " ( " ; SELF ; " ) " ; " with " ; label_expr_list ; " } " END ; DELETE_RULE Gram expr : " ( " ; SELF ; " , " ; comma_expr ; " ) " END ; DELETE_RULE Gram expr : SELF ; " " ; := SELF ; dummy END ; DELETE_RULE Gram expr : " " ; ~ a_LIDENT ; " " ; : SELF END ; DELETE_RULE Gram expr : " " ; ? a_LIDENT ; " " ; : SELF END ; value clear = Gram . Entry . clear ; clear ctyp ; clear patt ; clear a_UIDENT ; clear type_longident_and_parameters ; clear type_parameters ; clear ipatt ; clear labeled_ipatt ; clear semi ; clear do_sequence ; clear type_kind ; clear constructor_arg_list ; clear poly_type ; clear class_name_and_param ; clear class_longident_and_param ; clear class_type_longident_and_param ; clear class_type_plus ; clear type_constraint ; clear comma_patt ; clear sequence ; clear sem_expr_for_list ; clear sem_expr ; clear label_declaration ; clear star_ctyp ; clear match_case ; clear with_constr ; clear package_type ; clear top_phrase ; EXTEND Gram GLOBAL : a_CHAR a_FLOAT a_INT a_INT32 a_INT64 a_LABEL a_LIDENT a_NATIVEINT a_OPTLABEL a_STRING a_UIDENT a_ident amp_ctyp and_ctyp match_case match_case0 match_case_quot binding binding_quot class_declaration class_description class_expr class_expr_quot class_fun_binding class_fun_def class_info_for_class_expr class_info_for_class_type class_longident class_longident_and_param class_name_and_param class_sig_item class_sig_item_quot class_signature class_str_item class_str_item_quot class_structure class_type class_type_declaration class_type_longident class_type_longident_and_param class_type_plus class_type_quot comma_ctyp comma_expr comma_ipatt comma_patt comma_type_parameter constrain constructor_arg_list constructor_declaration constructor_declarations ctyp ctyp_quot cvalue_binding direction_flag dummy eq_expr expr expr_eoi expr_quot fun_binding fun_def ident ident_quot implem interf ipatt ipatt_tcon label label_declaration label_declaration_list label_expr label_expr_list label_longident label_patt_list meth_list labeled_ipatt let_binding module_binding module_binding0 module_binding_quot module_declaration module_expr module_expr_quot module_longident module_longident_with_app module_rec_declaration module_type module_type_quot more_ctyp name_tags opt_as_lident opt_class_self_patt opt_class_self_type opt_comma_ctyp opt_dot_dot opt_eq_ctyp opt_expr opt_meth_list opt_mutable opt_polyt opt_private opt_rec opt_virtual opt_when_expr patt patt_as_patt_opt patt_eoi patt_quot patt_tcon phrase poly_type row_field sem_expr sem_expr_for_list sem_patt sem_patt_for_list semi sequence sig_item sig_item_quot sig_items star_ctyp str_item str_item_quot str_items top_phrase type_constraint type_declaration type_ident_and_parameters type_kind type_longident type_longident_and_parameters type_parameter type_parameters typevars use_file val_longident value_let value_val with_constr with_constr_quot infixop0 infixop1 infixop2 infixop3 infixop4 do_sequence package_type ; sem_expr : [ [ e1 = expr LEVEL " top " ; " ; " ; e2 = SELF -> <: expr < $ e1 ; $ $ e2 $ >> | e = expr LEVEL " top " ; " ; " -> e | e = expr LEVEL " top " -> e ] ] ; sequence : [ [ e = sem_expr -> e ] ] ; do_sequence : [ [ seq = sequence ; " done " -> seq ] ] ; sem_expr_for_list : [ [ e = expr LEVEL " top " ; " ; " ; el = SELF -> fun acc -> <: expr < [ $ e $ :: $ el acc $ ] >> | e = expr LEVEL " top " ; " ; " -> fun acc -> <: expr < [ $ e $ :: $ acc $ ] >> | e = expr LEVEL " top " -> fun acc -> <: expr < [ $ e $ :: $ acc $ ] >> ] ] ; str_item : [ " top " [ " let " ; r = opt_rec ; bi = binding ; " in " ; x = expr -> <: str_item < let $ rec : r $ $ bi $ in $ x $ >> | " let " ; r = opt_rec ; bi = binding -> match bi with [ <: binding < _ = $ e $ >> -> <: str_item < $ exp : e $ >> | _ -> <: str_item < value $ rec : r $ $ bi $ >> ] | " let " ; " module " ; m = a_UIDENT ; mb = module_binding0 ; " in " ; e = expr -> <: str_item < let module $ m $ = $ mb $ in $ e $ >> | " let " ; " open " ; i = module_longident ; " in " ; e = expr -> <: str_item < let open $ id : i $ in $ e $ >> ] ] ; seq_expr : [ [ e1 = expr LEVEL " top " ; " ; " ; e2 = SELF -> conc_seq e1 e2 | e1 = expr LEVEL " top " ; " ; " -> e1 | e1 = expr LEVEL " top " -> e1 ] ] ; expr : BEFORE " top " [ " ; " [ e = seq_expr -> e ] ] ; expr : LEVEL " top " [ [ " let " ; r = opt_rec ; bi = binding ; " in " ; x = expr LEVEL " ; " -> <: expr < let $ rec : r $ $ bi $ in $ x $ >> | " let " ; " module " ; m = a_UIDENT ; mb = module_binding0 ; " in " ; e = expr LEVEL " ; " -> <: expr < let module $ m $ = $ mb $ in $ e $ >> | " let " ; " open " ; i = module_longident ; " in " ; e = expr LEVEL " ; " -> <: expr < let open $ id : i $ in $ e $ >> | " function " ; a = match_case -> <: expr < fun [ $ a $ ] >> | " if " ; e1 = SELF ; " then " ; e2 = expr LEVEL " top " ; " else " ; e3 = expr LEVEL " top " -> <: expr < if $ e1 $ then $ e2 $ else $ e3 $ >> | " if " ; e1 = SELF ; " then " ; e2 = expr LEVEL " top " -> <: expr < if $ e1 $ then $ e2 $ else ( ) >> ] ] ; expr : BEFORE " " || [ " , " [ e1 = SELF ; " , " ; e2 = comma_expr -> <: expr < ( $ e1 , $ $ e2 $ ) >> ] | " " := NONA [ e1 = SELF ; " " ; := e2 = expr LEVEL " top " -> <: expr < $ e1 . $ val := $ e2 $ >> | e1 = SELF ; " " ; <- e2 = expr LEVEL " top " -> match bigarray_set _loc e1 e2 with [ Some e -> e | None -> <: expr < $ e1 $ := $ e2 $ >> ] ] ] ; expr : AFTER " " ^ [ " " :: RIGHTA [ e1 = SELF ; " " ; :: e2 = SELF -> <: expr < [ $ e1 $ :: $ e2 ] $ >> ] ] ; expr : LEVEL " apply " [ [ e1 = SELF ; e2 = SELF -> match ( is_expr_constr_call e1 , e2 ) with [ ( True , <: expr < ( $ tup : e $ ) ) >> -> List . fold_left ( fun e1 e2 -> <: expr < $ e1 $ $ e2 $ ) >> e1 ( Ast . list_of_expr e [ ] ) | _ -> <: expr < $ e1 $ $ e2 $ >> ] ] ] ; expr : LEVEL " simple " [ [ " false " -> <: expr < False >> | " true " -> <: expr < True >> | " { " ; lel = TRY [ lel = label_expr_list ; " } " -> lel ] -> <: expr < { $ lel $ } >> | " { " ; e = TRY [ e = expr LEVEL " . " ; " with " -> e ] ; lel = label_expr_list ; " } " -> <: expr < { ( $ e ) $ with $ lel $ } >> | " new " ; i = class_longident -> <: expr < new $ i $ >> ] ] ; val_longident : [ [ ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s -> <: ident < $ anti : mk_anti ~ c " : ident " n s $ >> | i = a_UIDENT -> <: ident < $ uid : i $ >> | i = a_LIDENT -> <: ident < $ lid : i $ >> | ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s ; " . " ; i = SELF -> <: ident < $ anti : mk_anti ~ c " : ident " n s . $$ i $ >> | i = a_UIDENT ; " . " ; j = SELF -> <: ident < $ uid : i . $$ j $ >> ] ] ; match_case : [ [ OPT " " ; | l = LIST1 match_case0 SEP " " | -> Ast . mcOr_of_list l ] ] ; patt_constr : [ [ i = module_longident -> <: patt < $ id : i $ >> | " ` " ; s = a_ident -> <: patt < ` $ s $ >> ] ] ; patt : [ " as " LEFTA [ p1 = SELF ; " as " ; i = a_LIDENT -> <: patt < ( $ p1 $ as $ lid : i ) $ >> ] | " " | LEFTA [ p1 = SELF ; " " ; | p2 = SELF -> <: patt < $ p1 $ | $ p2 $ >> ] | " , " [ p = SELF ; " , " ; pl = LIST1 NEXT SEP " , " -> <: patt < ( $ p , $ $ Ast . paCom_of_list pl $ ) >> ] | " " :: RIGHTA [ p1 = SELF ; " " ; :: p2 = SELF -> <: patt < [ $ p1 $ :: $ p2 ] $ >> ] | " apply " RIGHTA [ p1 = patt_constr ; p2 = SELF -> match p2 with [ <: patt < ( $ tup : p $ ) >> -> List . fold_left ( fun p1 p2 -> <: patt < $ p1 $ $ p2 $ ) >> p1 ( Ast . list_of_patt p [ ] ) | _ -> <: patt < $ p1 $ $ p2 $ >> ] | " lazy " ; p = SELF -> <: patt < lazy $ p $ >> | ` ANTIQUOT ( " " " | pat " " | anti " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt " n s $ >> | p = patt_constr -> p ] | " simple " [ ` ANTIQUOT ( " " " | pat " " | anti " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt " n s $ >> | ` ANTIQUOT ( " tup " as n ) s -> <: patt < ( $ tup :<: patt < $ anti : mk_anti ~ c " : patt " n s $ ) >>$ >> | ` ANTIQUOT ( " ` bool " as n ) s -> <: patt < $ anti : mk_anti n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . patt_tag | i = ident -> <: patt < $ id : i $ >> | s = a_INT -> <: patt < $ int : s $ >> | s = a_INT32 -> <: patt < $ int32 : s $ >> | s = a_INT64 -> <: patt < $ int64 : s $ >> | s = a_NATIVEINT -> <: patt < $ nativeint : s $ >> | " " ; - s = a_INT -> <: patt < $ int " " :- ^ s $ >> | " " ; - s = a_INT32 -> <: patt < $ int32 " " :- ^ s $ >> | " " ; - s = a_INT64 -> <: patt < $ int64 " " :- ^ s $ >> | " " ; - s = a_NATIVEINT -> <: patt < $ nativeint " " :- ^ s $ >> | " " ; - s = a_FLOAT -> <: patt < $ flo " " :- ^ s $ >> | s = a_FLOAT -> <: patt < $ flo : s $ >> | s = a_STRING -> <: patt < $ str : s $ >> | s1 = a_CHAR ; " . . " ; s2 = a_CHAR -> <: patt < $ chr : s1 $ . . $ chr : s2 $ >> | s = a_CHAR -> <: patt < $ chr : s $ >> | " false " -> <: patt < False >> | " true " -> <: patt < True >> | " [ " ; " ] " -> <: patt < [ ] >> | " [ " ; mk_list = sem_patt_for_list ; " " ; :: last = patt ; " ] " -> mk_list last | " [ " ; mk_list = sem_patt_for_list ; " ] " -> mk_list <: patt < [ ] >> | " [ " ; | " ] " | -> <: patt < [ ] || >> | " [ " ; | pl = sem_patt ; " ] " | -> <: patt < [ | $ pl $ ] | >> | " { " ; pl = label_patt_list ; " } " -> <: patt < { $ pl $ } >> | " ( " ; " ) " -> <: patt < ( ) >> | " ( " ; p = patt ; " " ; : t = ctyp ; " ) " -> <: patt < ( $ p $ : $ t ) $ >> | " ( " ; p = patt ; " ) " -> <: patt < $ p $ >> | " _ " -> <: patt < _ >> | " ` " ; s = a_ident -> <: patt < ` $ s $ >> | " " ; # i = type_longident -> <: patt < # $ i $ >> ] ] ; comma_expr : [ [ e1 = expr LEVEL " " ; := " , " ; e2 = SELF -> <: expr < $ e1 , $ $ e2 $ >> | e1 = expr LEVEL " " := -> e1 ] ] ; type_constraint : [ [ " constraint " -> ( ) ] ] ; with_constr : [ LEFTA [ wc1 = SELF ; " and " ; wc2 = SELF -> <: with_constr < $ wc1 $ and $ wc2 $ >> | ` ANTIQUOT ( " " " | with_constr " " | anti " " | list " as n ) s -> <: with_constr < $ anti : mk_anti ~ c " : with_constr " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . with_constr_tag | " type " ; ` ANTIQUOT ( " " " | typ " " | anti " as n ) s ; " " ; = t = opt_private_ctyp -> <: with_constr < type $ anti : mk_anti ~ c " : ctyp " n s $ = $ t $ >> | " type " ; t1 = type_longident_and_parameters ; " " ; = t2 = opt_private_ctyp -> <: with_constr < type $ t1 $ = $ t2 $ >> | " module " ; i1 = module_longident ; " " ; = i2 = module_longident_with_app -> <: with_constr < module $ i1 $ = $ i2 $ >> | " type " ; ` ANTIQUOT ( " " " | typ " " | anti " as n ) s ; " " ; := t = opt_private_ctyp -> <: with_constr < type $ anti : mk_anti ~ c " : ctyp " n s $ := $ t $ >> | " type " ; t1 = type_longident_and_parameters ; " " ; := t2 = opt_private_ctyp -> <: with_constr < type $ t1 $ := $ t2 $ >> | " module " ; i1 = module_longident ; " " ; := i2 = module_longident_with_app -> <: with_constr < module $ i1 $ := $ i2 $ >> ] ] ; package_type : [ [ i = module_longident_with_app -> <: module_type < $ id : i $ >> | i = module_longident_with_app ; " with " ; cs = package_type_cstrs -> <: module_type < $ id : i $ with $ cs $ >> ] ] ; package_type_cstr : [ [ " type " ; i = a_LIDENT ; " " ; = ty = ctyp -> <: with_constr < type $ lid : i $ = $ ty $ >> ] ] ; package_type_cstrs : [ [ c = package_type_cstr -> c | c = package_type_cstr ; " and " ; cs = package_type_cstrs -> <: with_constr < $ c $ and $ cs $ >> ] ] ; opt_private_ctyp : [ [ " private " ; t = ctyp -> <: ctyp < private $ t $ >> | t = ctyp -> t ] ] ; class_type_plus : [ [ i = lident_colon ; t = ctyp LEVEL " star " ; " " ; -> ct = SELF -> <: class_type < [ ~ $ i $ : $ t $ ] -> $ ct $ >> | " " ; ? i = a_LIDENT ; " " ; : t = ctyp LEVEL " star " ; " " ; -> ct = SELF -> <: class_type < [ ? $ i $ : $ t $ ] -> $ ct $ >> | i = OPTLABEL ; t = ctyp LEVEL " star " ; " " ; -> ct = SELF -> <: class_type < [ ? $ i $ : $ t $ ] -> $ ct $ >> | test_ctyp_minusgreater ; t = ctyp LEVEL " star " ; " " ; -> ct = SELF -> <: class_type < [ $ t $ ] -> $ ct $ >> | ct = class_type -> ct ] ] ; class_type_longident_and_param : [ [ " [ " ; t = comma_ctyp ; " ] " ; i = class_type_longident -> <: class_type < $ id : i $ [ $ t $ ] >> | i = class_type_longident -> <: class_type < $ id : i $ >> ] ] ; class_longident_and_param : [ [ " [ " ; t = comma_ctyp ; " ] " ; ci = class_longident -> <: class_expr < $ id : ci $ [ $ t $ ] >> | ci = class_longident -> <: class_expr < $ id : ci $ >> ] ] ; class_name_and_param : [ [ " [ " ; x = comma_type_parameter ; " ] " ; i = a_LIDENT -> ( i , x ) | i = a_LIDENT -> ( i , <: ctyp ) <>> ] ] ; ctyp : [ [ t1 = SELF ; " as " ; " ' " ; i = a_ident -> <: ctyp < $ t1 $ as ' $ i $ >> ] | " arrow " RIGHTA [ t1 = SELF ; " " ; -> t2 = SELF -> <: ctyp < $ t1 $ -> $ t2 $ >> | i = TRY [ i = a_LIDENT ; " " : -> i ] ; t1 = ctyp LEVEL " star " ; " " ; -> t2 = SELF -> <: ctyp < ( ~ $ i $ : $ t1 $ ) -> $ t2 $ >> | i = a_OPTLABEL ; t1 = ctyp LEVEL " star " ; " " ; -> t2 = SELF -> <: ctyp < ( ? $ i $ : $ t1 $ ) -> $ t2 $ >> | " " ; ? i = a_LIDENT ; " " ; : t1 = ctyp LEVEL " star " ; " " ; -> t2 = SELF -> <: ctyp < ( ? $ i $ : $ t1 $ ) -> $ t2 $ >> ] | " star " [ t = SELF ; " " ; * tl = star_ctyp -> <: ctyp < ( $ t $ * $ tl $ ) >> ] | " ctyp1 " [ t1 = SELF ; t2 = SELF -> <: ctyp < $ t2 $ $ t1 $ >> ] | " ctyp2 " [ t1 = SELF ; " . " ; t2 = SELF -> try <: ctyp < $ id : Ast . ident_of_ctyp t1 . $$ id : Ast . ident_of_ctyp t2 $ >> with [ Invalid_argument s -> raise ( Stream . Error s ) ] | t1 = SELF ; " ( " ; t2 = SELF ; " ) " -> let t = <: ctyp < $ t1 $ $ t2 $ >> in try <: ctyp < $ id : Ast . ident_of_ctyp t $ >> with [ Invalid_argument s -> raise ( Stream . Error s ) ] ] | " simple " [ " ' " ; i = a_ident -> <: ctyp < ' $ i $ >> | " _ " -> <: ctyp < _ >> | i = a_LIDENT -> <: ctyp < $ lid : i $ >> | i = a_UIDENT -> <: ctyp < $ uid : i $ >> | ` ANTIQUOT ( " " " | typ " " | anti " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` ANTIQUOT ( " tup " as n ) s -> <: ctyp < ( $ tup :<: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ ) >>$ >> | ` ANTIQUOT ( " id " as n ) s -> <: ctyp < $ id :<: ident < $ anti : mk_anti ~ c " : ident " n s $ >>$ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | " ( " ; t = SELF ; " , " ; mk = comma_ctyp_app ; " ) " ; i = ctyp LEVEL " ctyp2 " -> mk <: ctyp < $ i $ $ t $ >> | " ( " ; t = SELF ; " ) " -> <: ctyp < $ t $ >> | " " ; # i = class_longident -> <: ctyp < # $ i $ >> | " " ; < t = opt_meth_list ; " " > -> t | " [ " ; OPT " " ; | rfl = row_field ; " ] " -> <: ctyp < [ = $ rfl $ ] >> | " [ " ; " " ; > " ] " -> <: ctyp < [ > $<: ctyp <>>$ ] >> | " [ " ; " " ; > OPT " " ; | rfl = row_field ; " ] " -> <: ctyp < [ > $ rfl $ ] >> | " [ " ; < OPT " " ; | rfl = row_field ; " ] " -> <: ctyp < [ < $ rfl $ ] >> | " [ " ; < OPT " " ; | rfl = row_field ; " " ; > ntl = name_tags ; " ] " -> <: ctyp < [ < $ rfl $ > $ ntl $ ] >> | " ( " ; " module " ; p = package_type ; " ) " -> <: ctyp < ( module $ p ) $ >> ] ] ; meth_list : [ [ m = meth_decl -> ( m , <: row_var_flag ) <>> ] ] ; comma_ctyp_app : [ [ t1 = ctyp ; " , " ; t2 = SELF -> fun acc -> t2 <: ctyp < $ acc $ $ t1 $ >> | t = ctyp -> fun acc -> <: ctyp < $ acc $ $ t $ >> ] ] ; star_ctyp : [ [ ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " * n s $ >> | t1 = ctyp LEVEL " ctyp1 " ; " " ; * t2 = SELF -> <: ctyp < $ t1 $ * $ t2 $ >> | t = ctyp LEVEL " ctyp1 " -> t ] ] ; semi : [ [ " ; ; " -> ( ) | -> ( ) ] ] ; ipatt : [ [ p = patt -> p ] ] ; type_longident_and_parameters : [ [ " ( " ; tpl = type_parameters ; " ) " ; i = type_longident -> tpl <: ctyp < $ id : i $ >> | tp = type_parameter ; i = type_longident -> <: ctyp < $ id : i $ $ tp $ >> | i = type_longident -> <: ctyp < $ id : i $ >> ] ] ; type_parameters : [ [ t1 = type_parameter ; " , " ; t2 = SELF -> fun acc -> t2 <: ctyp < $ acc $ $ t1 $ >> | t = type_parameter -> fun acc -> <: ctyp < $ acc $ $ t $ >> ] ] ; type_ident_and_parameters : [ [ " ( " ; tpl = LIST1 type_parameter SEP " , " ; " ) " ; i = a_LIDENT -> ( i , tpl ) | t = type_parameter ; i = a_LIDENT -> ( i , [ t ] ) | i = a_LIDENT -> ( i , [ ] ) ] ] ; type_kind : [ [ " private " ; tk = type_kind -> <: ctyp < private $ tk $ >> | t = TRY [ OPT " " ; | t = constructor_declarations ; test_not_dot_nor_lparen -> t ] -> <: ctyp < [ $ t $ ] >> | t = TRY ctyp -> <: ctyp < $ t $ >> | t = TRY ctyp ; " " ; = " private " ; tk = type_kind -> <: ctyp < $ t $ == private $ tk $ >> | t1 = TRY ctyp ; " " ; = " { " ; t2 = label_declaration_list ; " } " -> <: ctyp < $ t1 $ == { $ t2 $ } >> | t1 = TRY ctyp ; " " ; = OPT " " ; | t2 = constructor_declarations -> <: ctyp < $ t1 $ == [ $ t2 $ ] >> | " { " ; t = label_declaration_list ; " } " -> <: ctyp < { $ t $ } >> ] ] ; ctyp_quot : [ [ " private " ; t = ctyp_quot -> <: ctyp < private $ t $ >> | " " ; | t = constructor_declarations -> <: ctyp < [ $ t $ ] >> | x = more_ctyp ; " " ; = y = ctyp_quot -> <: ctyp < $ x $ == $ y $ >> | " { " ; t = label_declaration_list ; " } " -> <: ctyp < { $ t $ } >> ] ] ; module_expr : LEVEL " apply " [ [ i = SELF ; " ( " ; j = SELF ; " ) " -> <: module_expr < $ i $ $ j $ >> ] ] ; ident_quot : LEVEL " apply " [ [ i = SELF ; " ( " ; j = SELF ; " ) " -> <: ident < $ i $ $ j $ >> ] ] ; module_longident_with_app : LEVEL " apply " [ [ i = SELF ; " ( " ; j = SELF ; " ) " -> <: ident < $ i $ $ j $ >> ] ] ; type_longident : LEVEL " apply " [ [ i = SELF ; " ( " ; j = SELF ; " ) " -> <: ident < $ i $ $ j $ >> ] ] ; constructor_arg_list : [ [ t1 = SELF ; " " ; * t2 = SELF -> <: ctyp < $ t1 $ and $ t2 $ >> | t = ctyp LEVEL " ctyp1 " -> t ] ] ; value_let : [ [ " let " -> ( ) ] ] ; value_val : [ [ " val " -> ( ) ] ] ; label_declaration : [ [ ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | s = a_LIDENT ; " " ; : t = poly_type -> <: ctyp < $ lid : s $ : $ t $ >> | " mutable " ; s = a_LIDENT ; " " ; : t = poly_type -> <: ctyp < $ lid : s $ : mutable $ t $ >> ] ] ; poly_type : [ [ t1 = TRY [ t = typevars ; " . " -> t ] ; t2 = ctyp -> <: ctyp < ! $ t1 $ . $ t2 $ >> | t = TRY ctyp -> t ] ] ; labeled_ipatt : [ [ i = a_LABEL ; p = patt LEVEL " simple " -> <: patt < ~ $ i $ : $ p $ >> | " " ; ~ i = a_LIDENT -> <: patt < ~ $ i $ >> | " " ; ~ " ( " ; i = a_LIDENT ; " ) " -> <: patt < ~ $ i $ >> | " " ; ~ " ( " ; i = a_LIDENT ; " " ; : t = ctyp ; " ) " -> <: patt < ~ $ i $ : ( $ lid : i $ : $ t ) $ >> | i = a_OPTLABEL ; j = a_LIDENT -> <: patt < ? $ i $ : ( $ lid : j ) $ >> | i = a_OPTLABEL ; " _ " -> <: patt < ? $ i $ : ( _ ) >> | i = a_OPTLABEL ; " ( " ; p = patt ; " ) " -> <: patt < ? $ i $ : ( $ p ) $ >> | i = a_OPTLABEL ; " ( " ; p = patt ; " " ; = e = expr ; " ) " -> <: patt < ? $ i $ : ( $ p $ = $ e $ ) >> | i = a_OPTLABEL ; " ( " ; p = patt ; " " ; : t = ctyp ; " ) " -> <: patt < ? $ i $ : ( $ p $ : $ t $ ) >> | i = a_OPTLABEL ; " ( " ; p = patt ; " " ; : t = ctyp ; " " ; = e = expr ; " ) " -> <: patt < ? $ i $ : ( $ p $ : $ t $ = $ e $ ) >> | " " ; ? i = a_LIDENT -> <: patt < ? $ i $ >> | " " ; ? " ( " ; i = a_LIDENT ; " " ; = e = expr ; " ) " -> <: patt < ? ( $ lid : i $ = $ e $ ) >> | " " ; ? " ( " ; i = a_LIDENT ; " " ; : t = ctyp ; " " ; = e = expr ; " ) " -> <: patt < ? ( $ lid : i $ : $ t $ = $ e $ ) >> | " " ; ? " ( " ; i = a_LIDENT ; " ) " -> <: patt < ? $ i $ >> | " " ; ? " ( " ; i = a_LIDENT ; " " ; : t = ctyp ; " ) " -> <: patt < ? ( $ lid : i $ : $ t $ ) >> | p = patt LEVEL " simple " -> p ] ] ; label_expr : [ [ i = label_longident ; " " ; = e = expr LEVEL " top " -> <: rec_binding < $ i $ = $ e $ >> ] ] ; a_UIDENT : [ [ ` ANTIQUOT ( " " " | uid " as n ) s -> mk_anti n s | ` UIDENT " True " -> " True " | ` UIDENT " False " -> " False " | ` UIDENT s -> s ] ] ; top_phrase : [ [ " " ; # n = a_LIDENT ; dp = opt_expr ; " ; ; " -> Some <: str_item < # $ n $ $ dp $ >> | l = LIST1 str_item ; " ; ; " -> Some ( Ast . stSem_of_list l ) | ` EOI -> None ] ] ; END ; DELETE_RULE Gram module_longident_with_app : " ( " ; SELF ; " ) " END ; DELETE_RULE Gram type_longident : " ( " ; SELF ; " ) " END ; DELETE_RULE Gram ident_quot : " ( " ; SELF ; " ) " END ; DELETE_RULE Gram module_longident_with_app : SELF ; SELF END ; DELETE_RULE Gram type_longident : SELF ; SELF END ; DELETE_RULE Gram ident_quot : SELF ; SELF END ; DELETE_RULE Gram module_expr : SELF ; SELF END ; end ; |
let module M = Register . OCamlSyntaxExtension Id Make in ( ) ; |
module Id : Sig . Id = struct value name = " Camlp4OCamlParserParser " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) = struct open Sig ; include Syntax ; module M = Camlp4OCamlRevisedParserParser . Make Syntax ; open M ; Gram . Entry . clear stream_expr ; Gram . Entry . clear stream_begin ; Gram . Entry . clear stream_end ; Gram . Entry . clear stream_quot ; Gram . Entry . clear parser_case_list ; EXTEND Gram stream_expr : [ [ e = expr LEVEL " top " -> e ] ] ; stream_begin : [ [ " [ " < -> ( ) ] ] ; stream_end : [ [ " ] " > -> ( ) ] ] ; stream_quot : [ [ " ' " -> ( ) ] ] ; parser_case_list : [ [ OPT " " ; | pcl = LIST1 parser_case SEP " " | -> pcl ] ] ; END ; end ; |
let module M = Register . OCamlSyntaxExtension Id Make in ( ) ; |
module Id = struct value name = " Camlp4Reloaded " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) = struct open Sig ; include Syntax ; Gram . Entry . clear match_case ; Gram . Entry . clear semi ; value mkseq _loc = fun [ <: expr < $ _ ; $ $ _ $ >> as e -> <: expr < do { $ e $ } >> | e -> e ] ; DELETE_RULE Gram match_case0 : patt_as_patt_opt ; opt_when_expr ; " " ; -> expr END ; value revised = try ( DELETE_RULE Gram expr : " if " ; SELF ; " then " ; SELF ; " else " ; SELF END ; True ) with [ Not_found -> begin DELETE_RULE Gram expr : " if " ; SELF ; " then " ; expr LEVEL " top " ; " else " ; expr LEVEL " top " END ; DELETE_RULE Gram expr : " if " ; SELF ; " then " ; expr LEVEL " top " END ; False end ] ; if revised then begin DELETE_RULE Gram expr : " fun " ; " [ " ; LIST0 match_case0 SEP " " ; | " ] " END ; EXTEND Gram expr : LEVEL " top " [ [ " function " ; a = match_case -> <: expr < fun [ $ a $ ] >> ] ] ; END ; DELETE_RULE Gram value_let : " value " END ; DELETE_RULE Gram value_val : " value " END ; end else begin DELETE_RULE Gram value_let : " let " END ; DELETE_RULE Gram value_val : " val " END ; end ; EXTEND Gram GLOBAL : match_case match_case0 expr value_let value_val semi ; match_case : [ [ OPT " " ; | l = LIST1 match_case0 SEP " " ; | " end " -> Ast . mcOr_of_list l | " end " -> <: match_case <>> ] ] ; match_case0 : [ [ p = patt_as_patt_opt ; w = opt_when_expr ; " " ; -> e = sequence -> <: match_case < $ p $ when $ w $ -> $ mkseq _loc e $ >> ] ] ; expr : LEVEL " top " [ [ " if " ; e1 = sequence ; " then " ; e2 = sequence ; " else " ; e3 = sequence ; " end " -> <: expr < if $ mkseq _loc e1 $ then $ mkseq _loc e2 $ else $ mkseq _loc e3 $ >> | " if " ; e1 = sequence ; " then " ; e2 = sequence ; " end " -> <: expr < if $ mkseq _loc e1 $ then $ mkseq _loc e2 $ else ( ) >> ] ] ; value_let : [ [ " val " -> ( ) ] ] ; value_val : [ [ " val " -> ( ) ] ] ; semi : [ [ " ; ; " -> ( ) | " ; " -> ( ) | -> ( ) ] ] ; END ; end ; |
let module M = Register . OCamlSyntaxExtension Id Make in ( ) ; |
module Id = struct value name = " Camlp4OCamlRevisedParser " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) = struct open Sig ; include Syntax ; Camlp4_config . constructors_arity . val := False ; value help_sequences ( ) = do { Printf . eprintf " \ \ n " ; flush stderr ; exit 1 } ; Options . add " - help_seq " ( Arg . Unit help_sequences ) " Print explanations about new sequences and exit . " ; Gram . Entry . clear a_CHAR ; Gram . Entry . clear a_FLOAT ; Gram . Entry . clear a_INT ; Gram . Entry . clear a_INT32 ; Gram . Entry . clear a_INT64 ; Gram . Entry . clear a_LABEL ; Gram . Entry . clear a_LIDENT ; Gram . Entry . clear a_NATIVEINT ; Gram . Entry . clear a_OPTLABEL ; Gram . Entry . clear a_STRING ; Gram . Entry . clear a_UIDENT ; Gram . Entry . clear a_ident ; Gram . Entry . clear amp_ctyp ; Gram . Entry . clear and_ctyp ; Gram . Entry . clear match_case ; Gram . Entry . clear match_case0 ; Gram . Entry . clear match_case_quot ; Gram . Entry . clear binding ; Gram . Entry . clear binding_quot ; Gram . Entry . clear rec_binding_quot ; Gram . Entry . clear class_declaration ; Gram . Entry . clear class_description ; Gram . Entry . clear class_expr ; Gram . Entry . clear class_expr_quot ; Gram . Entry . clear class_fun_binding ; Gram . Entry . clear class_fun_def ; Gram . Entry . clear class_info_for_class_expr ; Gram . Entry . clear class_info_for_class_type ; Gram . Entry . clear class_longident ; Gram . Entry . clear class_longident_and_param ; Gram . Entry . clear class_name_and_param ; Gram . Entry . clear class_sig_item ; Gram . Entry . clear class_sig_item_quot ; Gram . Entry . clear class_signature ; Gram . Entry . clear class_str_item ; Gram . Entry . clear class_str_item_quot ; Gram . Entry . clear class_structure ; Gram . Entry . clear class_type ; Gram . Entry . clear class_type_declaration ; Gram . Entry . clear class_type_longident ; Gram . Entry . clear class_type_longident_and_param ; Gram . Entry . clear class_type_plus ; Gram . Entry . clear class_type_quot ; Gram . Entry . clear comma_ctyp ; Gram . Entry . clear comma_expr ; Gram . Entry . clear comma_ipatt ; Gram . Entry . clear comma_patt ; Gram . Entry . clear comma_type_parameter ; Gram . Entry . clear constrain ; Gram . Entry . clear constructor_arg_list ; Gram . Entry . clear constructor_declaration ; Gram . Entry . clear constructor_declarations ; Gram . Entry . clear ctyp ; Gram . Entry . clear ctyp_quot ; Gram . Entry . clear cvalue_binding ; Gram . Entry . clear direction_flag ; Gram . Entry . clear dummy ; Gram . Entry . clear eq_expr ; Gram . Entry . clear expr ; Gram . Entry . clear expr_eoi ; Gram . Entry . clear expr_quot ; Gram . Entry . clear field_expr ; Gram . Entry . clear field_expr_list ; Gram . Entry . clear fun_binding ; Gram . Entry . clear fun_def ; Gram . Entry . clear ident ; Gram . Entry . clear ident_quot ; Gram . Entry . clear implem ; Gram . Entry . clear interf ; Gram . Entry . clear ipatt ; Gram . Entry . clear ipatt_tcon ; Gram . Entry . clear label ; Gram . Entry . clear label_declaration ; Gram . Entry . clear label_declaration_list ; Gram . Entry . clear label_expr_list ; Gram . Entry . clear label_expr ; Gram . Entry . clear label_ipatt ; Gram . Entry . clear label_ipatt_list ; Gram . Entry . clear label_longident ; Gram . Entry . clear label_patt ; Gram . Entry . clear label_patt_list ; Gram . Entry . clear labeled_ipatt ; Gram . Entry . clear let_binding ; Gram . Entry . clear meth_list ; Gram . Entry . clear meth_decl ; Gram . Entry . clear module_binding ; Gram . Entry . clear module_binding0 ; Gram . Entry . clear module_binding_quot ; Gram . Entry . clear module_declaration ; Gram . Entry . clear module_expr ; Gram . Entry . clear module_expr_quot ; Gram . Entry . clear module_longident ; Gram . Entry . clear module_longident_with_app ; Gram . Entry . clear module_rec_declaration ; Gram . Entry . clear module_type ; Gram . Entry . clear module_type_quot ; Gram . Entry . clear more_ctyp ; Gram . Entry . clear name_tags ; Gram . Entry . clear opt_as_lident ; Gram . Entry . clear opt_class_self_patt ; Gram . Entry . clear opt_class_self_type ; Gram . Entry . clear opt_comma_ctyp ; Gram . Entry . clear opt_dot_dot ; Gram . Entry . clear opt_eq_ctyp ; Gram . Entry . clear opt_expr ; Gram . Entry . clear opt_meth_list ; Gram . Entry . clear opt_mutable ; Gram . Entry . clear opt_polyt ; Gram . Entry . clear opt_private ; Gram . Entry . clear opt_rec ; Gram . Entry . clear opt_virtual ; Gram . Entry . clear opt_when_expr ; Gram . Entry . clear patt ; Gram . Entry . clear patt_as_patt_opt ; Gram . Entry . clear patt_eoi ; Gram . Entry . clear patt_quot ; Gram . Entry . clear patt_tcon ; Gram . Entry . clear phrase ; Gram . Entry . clear poly_type ; Gram . Entry . clear row_field ; Gram . Entry . clear sem_expr ; Gram . Entry . clear sem_expr_for_list ; Gram . Entry . clear sem_patt ; Gram . Entry . clear sem_patt_for_list ; Gram . Entry . clear semi ; Gram . Entry . clear sequence ; Gram . Entry . clear sig_item ; Gram . Entry . clear sig_item_quot ; Gram . Entry . clear sig_items ; Gram . Entry . clear star_ctyp ; Gram . Entry . clear str_item ; Gram . Entry . clear str_item_quot ; Gram . Entry . clear str_items ; Gram . Entry . clear top_phrase ; Gram . Entry . clear type_constraint ; Gram . Entry . clear type_declaration ; Gram . Entry . clear type_ident_and_parameters ; Gram . Entry . clear type_kind ; Gram . Entry . clear type_longident ; Gram . Entry . clear type_longident_and_parameters ; Gram . Entry . clear type_parameter ; Gram . Entry . clear type_parameters ; Gram . Entry . clear typevars ; Gram . Entry . clear use_file ; Gram . Entry . clear val_longident ; Gram . Entry . clear value_let ; Gram . Entry . clear value_val ; Gram . Entry . clear with_constr ; Gram . Entry . clear with_constr_quot ; value neg_string n = let len = String . length n in if len > 0 && n . [ 0 ] = ' ' - then String . sub n 1 ( len - 1 ) else " " - ^ n ; value mkumin _loc f arg = match arg with [ <: expr < $ int : n $ >> -> <: expr < $ int : neg_string n $ >> | <: expr < $ int32 : n $ >> -> <: expr < $ int32 : neg_string n $ >> | <: expr < $ int64 : n $ >> -> <: expr < $ int64 : neg_string n $ >> | <: expr < $ nativeint : n $ >> -> <: expr < $ nativeint : neg_string n $ >> | <: expr < $ flo : n $ >> -> <: expr < $ flo : neg_string n $ >> | _ -> <: expr < $ lid " " :~ ^ f $ $ arg $ >> ] ; value mklistexp _loc last = loop True where rec loop top = fun [ [ ] -> match last with [ Some e -> e | None -> <: expr < [ ] >> ] | [ e1 :: el ] -> let _loc = if top then _loc else Loc . merge ( Ast . loc_of_expr e1 ) _loc in <: expr < [ $ e1 $ :: $ loop False el ] $ >> ] ; value mkassert _loc = fun [ <: expr < False >> -> <: expr < assert False >> | e -> <: expr < assert $ e $ >> ] ; value append_eLem el e = el @ [ e ] ; value mk_anti ( ? c = " " ) n s = " " \\$^ n ^ c " " ^:^ s ; value mksequence _loc = fun [ <: expr < $ _ ; $ $ _ $ >> | <: expr < $ anti : _ $ >> as e -> <: expr < do { $ e $ } >> | e -> e ] ; value mksequence ' _loc = fun [ <: expr < $ _ ; $ $ _ $ >> as e -> <: expr < do { $ e $ } >> | e -> e ] ; value rec lid_of_ident = fun [ <: ident < $ _ $ . $ i $ >> -> lid_of_ident i | <: ident < $ lid : lid $ >> -> lid | _ -> assert False ] ; value module_type_app mt1 mt2 = match ( mt1 , mt2 ) with [ ( <: module_type @ _loc < $ id : i1 $ , >> <: module_type < $ id : i2 $ ) >> -> <: module_type < $ id :<: ident < $ i1 $ $ i2 $ >>$ >> | _ -> raise Stream . Failure ] ; value module_type_acc mt1 mt2 = match ( mt1 , mt2 ) with [ ( <: module_type @ _loc < $ id : i1 $ , >> <: module_type < $ id : i2 $ ) >> -> <: module_type < $ id :<: ident < $ i1 . $$ i2 $ >>$ >> | _ -> raise Stream . Failure ] ; value bigarray_get _loc arr arg = let coords = match arg with [ <: expr < ( $ e1 , $ $ e2 ) $ >> | <: expr < $ e1 , $ $ e2 $ >> -> Ast . list_of_expr e1 ( Ast . list_of_expr e2 [ ] ) | _ -> [ arg ] ] in match coords with [ [ c1 ] -> <: expr < Bigarray . Array1 . get $ arr $ $ c1 $ >> | [ c1 ; c2 ] -> <: expr < Bigarray . Array2 . get $ arr $ $ c1 $ $ c2 $ >> | [ c1 ; c2 ; c3 ] -> <: expr < Bigarray . Array3 . get $ arr $ $ c1 $ $ c2 $ $ c3 $ >> | coords -> <: expr < Bigarray . Genarray . get $ arr $ [ | $ Ast . exSem_of_list coords $ ] | >> ] ; value bigarray_set _loc var newval = match var with [ <: expr < Bigarray . Array1 . get $ arr $ $ c1 $ >> -> Some <: expr < Bigarray . Array1 . set $ arr $ $ c1 $ $ newval $ >> | <: expr < Bigarray . Array2 . get $ arr $ $ c1 $ $ c2 $ >> -> Some <: expr < Bigarray . Array2 . set $ arr $ $ c1 $ $ c2 $ $ newval $ >> | <: expr < Bigarray . Array3 . get $ arr $ $ c1 $ $ c2 $ $ c3 $ >> -> Some <: expr < Bigarray . Array3 . set $ arr $ $ c1 $ $ c2 $ $ c3 $ $ newval $ >> | <: expr < Bigarray . Genarray . get $ arr $ [ | $ coords $ ] | >> -> Some <: expr < Bigarray . Genarray . set $ arr $ [ | $ coords $ ] | $ newval $ >> | _ -> None ] ; value stopped_at _loc = Some ( Loc . move_line 1 _loc ) ; value symbolchar = let list = [ ' ' ; $ ' ' ; ! ' ' ; % ' ' ; & ' ' ; * ' ' ; + ' ' ; - ' . ' ; ' ' ; / ' ' ; : ' ' ; < ' ' ; = ' ' ; > ' ' ; ? ' ' ; @ ' ' ; ^ ' ' ; | ' ' ; ~ ' ' ] \\ in let rec loop s i = if i == String . length s then True else if List . mem s . [ i ] list then loop s ( i + 1 ) else False in loop ; value setup_op_parser entry p = Gram . Entry . setup_parser entry ( parser [ : ` ( KEYWORD x | SYMBOL x , ti ) when p x ] : -> let _loc = Gram . token_location ti in <: expr < $ lid : x $ ) ; >> let list = [ ' ' ; ! ' ' ; ? ' ' ] ~ in let excl = [ " " ; != " " ] ?? in setup_op_parser prefixop ( fun x -> not ( List . mem x excl ) && String . length x >= 2 && List . mem x . [ 0 ] list && symbolchar x 1 ) ; let list_ok = [ " " ; < " " ; > " " ; <= " " ; >= " " ; = " " ; <> " " ; == " " ; != " " ] $ in let list_first_char_ok = [ ' ' ; = ' ' ; < ' ' ; > ' ' ; | ' ' ; & ' ' ; $ ' ' ] ! in let excl = [ " " ; <- " " ; || " " ] && in setup_op_parser infixop0 ( fun x -> ( List . mem x list_ok ) || ( not ( List . mem x excl ) && String . length x >= 2 && List . mem x . [ 0 ] list_first_char_ok && symbolchar x 1 ) ) ; let list = [ ' ' ; @ ' ' ] ^ in setup_op_parser infixop1 ( fun x -> String . length x >= 1 && List . mem x . [ 0 ] list && symbolchar x 1 ) ; let list = [ ' ' ; + ' ' ] - in setup_op_parser infixop2 ( fun x -> x <> " " -> && String . length x >= 1 && List . mem x . [ 0 ] list && symbolchar x 1 ) ; let list = [ ' ' ; * ' ' ; / ' ' ; % ' ' ] \\ in setup_op_parser infixop3 ( fun x -> String . length x >= 1 && List . mem x . [ 0 ] list && ( x . [ 0 ] <> ' ' * || String . length x < 2 || x . [ 1 ] <> ' ' ) * && symbolchar x 1 ) ; setup_op_parser infixop4 ( fun x -> String . length x >= 2 && x . [ 0 ] == ' ' * && x . [ 1 ] == ' ' * && symbolchar x 2 ) ; value rec infix_kwds_filter = parser [ [ : ` ( ( KEYWORD " ( " , _ ) as tok ) ; xs ] : -> match xs with parser [ [ : ` ( KEYWORD ( " mod " " | land " " | lor " " | lxor " " | lsl " " | lsr " " | asr " as i ) , _loc ) ; ` ( KEYWORD " ) " , _ ) ; xs ] : -> [ : ` ( LIDENT i , _loc ) ; infix_kwds_filter xs ] : | [ : xs ] : -> [ : ` tok ; infix_kwds_filter xs ] : ] | [ : ` x ; xs ] : -> [ : ` x ; infix_kwds_filter xs ] : ] ; Token . Filter . define_filter ( Gram . get_filter ( ) ) ( fun f strm -> infix_kwds_filter ( f strm ) ) ; Gram . Entry . setup_parser sem_expr begin let symb1 = Gram . parse_tokens_after_filter expr in let symb = parser [ [ : ` ( ANTIQUOT ( " list " as n ) s , ti ) ] : -> let _loc = Gram . token_location ti in <: expr < $ anti : mk_anti ~ c " : expr ; " n s $ >> | [ : a = symb1 ] : -> a ] in let rec kont al = parser [ [ : ` ( KEYWORD " ; " , _ ) ; a = symb ; s ] : -> let _loc = Loc . merge ( Ast . loc_of_expr al ) ( Ast . loc_of_expr a ) in kont <: expr < $ al ; $ $ a $ >> s | [ : ] : -> al ] in parser [ : a = symb ; s ] : -> kont a s end ; EXTEND Gram GLOBAL : a_CHAR a_FLOAT a_INT a_INT32 a_INT64 a_LABEL a_LIDENT rec_binding_quot a_NATIVEINT a_OPTLABEL a_STRING a_UIDENT a_ident amp_ctyp and_ctyp match_case match_case0 match_case_quot binding binding_quot class_declaration class_description class_expr class_expr_quot class_fun_binding class_fun_def class_info_for_class_expr class_info_for_class_type class_longident class_longident_and_param class_name_and_param class_sig_item class_sig_item_quot class_signature class_str_item class_str_item_quot class_structure class_type class_type_declaration class_type_longident class_type_longident_and_param class_type_plus class_type_quot comma_ctyp comma_expr comma_ipatt comma_patt comma_type_parameter constrain constructor_arg_list constructor_declaration constructor_declarations ctyp ctyp_quot cvalue_binding direction_flag dummy eq_expr expr expr_eoi expr_quot field_expr field_expr_list fun_binding fun_def ident ident_quot implem interf ipatt ipatt_tcon label label_declaration label_declaration_list label_expr label_expr_list label_ipatt label_ipatt_list label_longident label_patt label_patt_list labeled_ipatt let_binding meth_list meth_decl module_binding module_binding0 module_binding_quot module_declaration module_expr module_expr_quot module_longident module_longident_with_app module_rec_declaration module_type module_type_quot more_ctyp name_tags opt_as_lident opt_class_self_patt opt_class_self_type opt_comma_ctyp opt_dot_dot opt_eq_ctyp opt_expr opt_meth_list opt_mutable opt_polyt opt_private opt_rec opt_virtual opt_when_expr patt patt_as_patt_opt patt_eoi patt_quot patt_tcon phrase poly_type row_field sem_expr sem_expr_for_list sem_patt sem_patt_for_list semi sequence sig_item sig_item_quot sig_items star_ctyp str_item str_item_quot str_items top_phrase type_constraint type_declaration type_ident_and_parameters type_kind type_longident type_longident_and_parameters type_parameter type_parameters typevars use_file val_longident value_let value_val with_constr with_constr_quot infixop0 infixop1 infixop2 infixop3 infixop4 do_sequence package_type rec_flag_quot direction_flag_quot mutable_flag_quot private_flag_quot virtual_flag_quot row_var_flag_quot override_flag_quot ; module_expr : [ " top " [ " functor " ; " ( " ; i = a_UIDENT ; " " ; : t = module_type ; " ) " ; " " ; -> me = SELF -> <: module_expr < functor ( $ i $ : $ t $ ) -> $ me $ >> | " struct " ; st = str_items ; " end " -> <: module_expr < struct $ st $ end >> ] | " apply " [ me1 = SELF ; me2 = SELF -> <: module_expr < $ me1 $ $ me2 $ >> ] | " simple " [ ` ANTIQUOT ( " " " | mexp " " | anti " " | list " as n ) s -> <: module_expr < $ anti : mk_anti ~ c " : module_expr " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . module_expr_tag | i = module_longident -> <: module_expr < $ id : i $ >> | " ( " ; me = SELF ; " " ; : mt = module_type ; " ) " -> <: module_expr < ( $ me $ : $ mt $ ) >> | " ( " ; me = SELF ; " ) " -> <: module_expr < $ me $ >> | " ( " ; value_val ; e = expr ; " ) " -> <: module_expr < ( value $ e ) $ >> | " ( " ; value_val ; e = expr ; " " ; : p = package_type ; " ) " -> <: module_expr < ( value $ e $ : $ p ) $ >> ] ] ; str_item : [ " top " [ " exception " ; t = constructor_declaration -> <: str_item < exception $ t $ >> | " exception " ; t = constructor_declaration ; " " ; = i = type_longident -> <: str_item < exception $ t $ = $ i $ >> | " external " ; i = a_LIDENT ; " " ; : t = ctyp ; " " ; = sl = string_list -> <: str_item < external $ i $ : $ t $ = $ sl $ >> | " include " ; me = module_expr -> <: str_item < include $ me $ >> | " module " ; i = a_UIDENT ; mb = module_binding0 -> <: str_item < module $ i $ = $ mb $ >> | " module " ; " rec " ; mb = module_binding -> <: str_item < module rec $ mb $ >> | " module " ; " type " ; i = a_ident ; " " ; = mt = module_type -> <: str_item < module type $ i $ = $ mt $ >> | " open " ; i = module_longident -> <: str_item < open $ i $ >> | " type " ; td = type_declaration -> <: str_item < type $ td $ >> | value_let ; r = opt_rec ; bi = binding -> <: str_item < value $ rec : r $ $ bi $ >> | " class " ; cd = class_declaration -> <: str_item < class $ cd $ >> | " class " ; " type " ; ctd = class_type_declaration -> <: str_item < class type $ ctd $ >> | ` ANTIQUOT ( " " " | stri " " | anti " " | list " as n ) s -> <: str_item < $ anti : mk_anti ~ c " : str_item " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . str_item_tag | e = expr -> <: str_item < $ exp : e $ >> ] ] ; module_binding0 : [ RIGHTA [ " ( " ; m = a_UIDENT ; " " ; : mt = module_type ; " ) " ; mb = SELF -> <: module_expr < functor ( $ m $ : $ mt $ ) -> $ mb $ >> | " " ; : mt = module_type ; " " ; = me = module_expr -> <: module_expr < ( $ me $ : $ mt $ ) >> | " " ; = me = module_expr -> <: module_expr < $ me $ >> ] ] ; module_binding : [ LEFTA [ b1 = SELF ; " and " ; b2 = SELF -> <: module_binding < $ b1 $ and $ b2 $ >> | ` ANTIQUOT ( " module_binding " " | anti " " | list " as n ) s -> <: module_binding < $ anti : mk_anti ~ c " : module_binding " n s $ >> | ` ANTIQUOT ( " " as n ) s -> <: module_binding < $ anti : mk_anti ~ c " : module_binding " n s $ >> | ` ANTIQUOT ( " " as n ) m ; " " ; : mt = module_type ; " " ; = me = module_expr -> <: module_binding < $ mk_anti n m $ : $ mt $ = $ me $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . module_binding_tag | m = a_UIDENT ; " " ; : mt = module_type ; " " ; = me = module_expr -> <: module_binding < $ m $ : $ mt $ = $ me $ >> ] ] ; module_type : [ " top " [ " functor " ; " ( " ; i = a_UIDENT ; " " ; : t = SELF ; " ) " ; " " ; -> mt = SELF -> <: module_type < functor ( $ i $ : $ t $ ) -> $ mt $ >> ] | " with " [ mt = SELF ; " with " ; wc = with_constr -> <: module_type < $ mt $ with $ wc $ >> ] | " apply " [ mt1 = SELF ; mt2 = SELF ; dummy -> module_type_app mt1 mt2 ] | " . " [ mt1 = SELF ; " . " ; mt2 = SELF -> module_type_acc mt1 mt2 ] | " sig " [ " sig " ; sg = sig_items ; " end " -> <: module_type < sig $ sg $ end >> ] | " simple " [ ` ANTIQUOT ( " " " | mtyp " " | anti " " | list " as n ) s -> <: module_type < $ anti : mk_anti ~ c " : module_type " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . module_type_tag | i = module_longident_with_app -> <: module_type < $ id : i $ >> | " ' " ; i = a_ident -> <: module_type < ' $ i $ >> | " ( " ; mt = SELF ; " ) " -> <: module_type < $ mt $ >> | " module " ; " type " ; " of " ; me = module_expr -> <: module_type < module type of $ me $ >> ] ] ; sig_item : [ " top " [ ` ANTIQUOT ( " " " | sigi " " | anti " " | list " as n ) s -> <: sig_item < $ anti : mk_anti ~ c " : sig_item " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . sig_item_tag | " exception " ; t = constructor_declaration -> <: sig_item < exception $ t $ >> | " external " ; i = a_LIDENT ; " " ; : t = ctyp ; " " ; = sl = string_list -> <: sig_item < external $ i $ : $ t $ = $ sl $ >> | " include " ; mt = module_type -> <: sig_item < include $ mt $ >> | " module " ; i = a_UIDENT ; mt = module_declaration -> <: sig_item < module $ i $ : $ mt $ >> | " module " ; " rec " ; mb = module_rec_declaration -> <: sig_item < module rec $ mb $ >> | " module " ; " type " ; i = a_ident ; " " ; = mt = module_type -> <: sig_item < module type $ i $ = $ mt $ >> | " module " ; " type " ; i = a_ident -> <: sig_item < module type $ i $ >> | " open " ; i = module_longident -> <: sig_item < open $ i $ >> | " type " ; t = type_declaration -> <: sig_item < type $ t $ >> | value_val ; i = a_LIDENT ; " " ; : t = ctyp -> <: sig_item < value $ i $ : $ t $ >> | " class " ; cd = class_description -> <: sig_item < class $ cd $ >> | " class " ; " type " ; ctd = class_type_declaration -> <: sig_item < class type $ ctd $ >> ] ] ; module_declaration : [ RIGHTA [ " " ; : mt = module_type -> <: module_type < $ mt $ >> | " ( " ; i = a_UIDENT ; " " ; : t = module_type ; " ) " ; mt = SELF -> <: module_type < functor ( $ i $ : $ t $ ) -> $ mt $ >> ] ] ; module_rec_declaration : [ LEFTA [ m1 = SELF ; " and " ; m2 = SELF -> <: module_binding < $ m1 $ and $ m2 $ >> | ` ANTIQUOT ( " " " | module_binding " " | anti " " | list " as n ) s -> <: module_binding < $ anti : mk_anti ~ c " : module_binding " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . module_binding_tag | m = a_UIDENT ; " " ; : mt = module_type -> <: module_binding < $ m $ : $ mt $ >> ] ] ; with_constr : [ LEFTA [ wc1 = SELF ; " and " ; wc2 = SELF -> <: with_constr < $ wc1 $ and $ wc2 $ >> | ` ANTIQUOT ( " " " | with_constr " " | anti " " | list " as n ) s -> <: with_constr < $ anti : mk_anti ~ c " : with_constr " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . with_constr_tag | " type " ; ` ANTIQUOT ( " " " | typ " " | anti " as n ) s ; " " ; = t = ctyp -> <: with_constr < type $ anti : mk_anti ~ c " : ctyp " n s $ = $ t $ >> | " type " ; t1 = type_longident_and_parameters ; " " ; = t2 = ctyp -> <: with_constr < type $ t1 $ = $ t2 $ >> | " module " ; i1 = module_longident ; " " ; = i2 = module_longident_with_app -> <: with_constr < module $ i1 $ = $ i2 $ >> | " type " ; ` ANTIQUOT ( " " " | typ " " | anti " as n ) s ; " " ; := t = ctyp -> <: with_constr < type $ anti : mk_anti ~ c " : ctyp " n s $ := $ t $ >> | " type " ; t1 = type_longident_and_parameters ; " " ; := t2 = ctyp -> <: with_constr < type $ t1 $ := $ t2 $ >> | " module " ; i1 = module_longident ; " " ; := i2 = module_longident_with_app -> <: with_constr < module $ i1 $ := $ i2 $ >> ] ] ; expr : [ " top " RIGHTA [ " let " ; r = opt_rec ; bi = binding ; " in " ; x = SELF -> <: expr < let $ rec : r $ $ bi $ in $ x $ >> | " let " ; " module " ; m = a_UIDENT ; mb = module_binding0 ; " in " ; e = SELF -> <: expr < let module $ m $ = $ mb $ in $ e $ >> | " let " ; " open " ; i = module_longident ; " in " ; e = SELF -> <: expr < let open $ id : i $ in $ e $ >> | " fun " ; " [ " ; a = LIST0 match_case0 SEP " " ; | " ] " -> <: expr < fun [ $ list : a $ ] >> | " fun " ; e = fun_def -> e | " match " ; e = sequence ; " with " ; a = match_case -> <: expr < match $ mksequence ' _loc e $ with [ $ a $ ] >> | " try " ; e = sequence ; " with " ; a = match_case -> <: expr < try $ mksequence ' _loc e $ with [ $ a $ ] >> | " if " ; e1 = SELF ; " then " ; e2 = SELF ; " else " ; e3 = SELF -> <: expr < if $ e1 $ then $ e2 $ else $ e3 $ >> | " do " ; seq = do_sequence -> mksequence _loc seq | " for " ; i = a_LIDENT ; " " ; = e1 = sequence ; df = direction_flag ; e2 = sequence ; " do " ; seq = do_sequence -> <: expr < for $ i $ = $ mksequence ' _loc e1 $ $ to : df $ $ mksequence ' _loc e2 $ do { $ seq $ } >> | " while " ; e = sequence ; " do " ; seq = do_sequence -> <: expr < while $ mksequence ' _loc e $ do { $ seq $ } >> | " object " ; csp = opt_class_self_patt ; cst = class_structure ; " end " -> <: expr < object ( $ csp ) $ $ cst $ end >> ] | " where " [ e = SELF ; " where " ; rf = opt_rec ; lb = let_binding -> <: expr < let $ rec : rf $ $ lb $ in $ e $ >> ] | " " := NONA [ e1 = SELF ; " " ; := e2 = SELF ; dummy -> match bigarray_set _loc e1 e2 with [ Some e -> e | None -> <: expr < $ e1 $ := $ e2 $ >> ] ] | " " || RIGHTA [ e1 = SELF ; op = infixop6 ; e2 = SELF -> <: expr < $ op $ $ e1 $ $ e2 $ >> ] | " " && RIGHTA [ e1 = SELF ; op = infixop5 ; e2 = SELF -> <: expr < $ op $ $ e1 $ $ e2 $ >> ] | " " < LEFTA [ e1 = SELF ; op = infixop0 ; e2 = SELF -> <: expr < $ op $ $ e1 $ $ e2 $ >> ] | " " ^ RIGHTA [ e1 = SELF ; op = infixop1 ; e2 = SELF -> <: expr < $ op $ $ e1 $ $ e2 $ >> ] | " " + LEFTA [ e1 = SELF ; op = infixop2 ; e2 = SELF -> <: expr < $ op $ $ e1 $ $ e2 $ >> ] | " " * LEFTA [ e1 = SELF ; " land " ; e2 = SELF -> <: expr < $ e1 $ land $ e2 $ >> | e1 = SELF ; " lor " ; e2 = SELF -> <: expr < $ e1 $ lor $ e2 $ >> | e1 = SELF ; " lxor " ; e2 = SELF -> <: expr < $ e1 $ lxor $ e2 $ >> | e1 = SELF ; " mod " ; e2 = SELF -> <: expr < $ e1 $ mod $ e2 $ >> | e1 = SELF ; op = infixop3 ; e2 = SELF -> <: expr < $ op $ $ e1 $ $ e2 $ >> ] | " " ** RIGHTA [ e1 = SELF ; " asr " ; e2 = SELF -> <: expr < $ e1 $ asr $ e2 $ >> | e1 = SELF ; " lsl " ; e2 = SELF -> <: expr < $ e1 $ lsl $ e2 $ >> | e1 = SELF ; " lsr " ; e2 = SELF -> <: expr < $ e1 $ lsr $ e2 $ >> | e1 = SELF ; op = infixop4 ; e2 = SELF -> <: expr < $ op $ $ e1 $ $ e2 $ >> ] | " unary minus " NONA [ " " ; - e = SELF -> mkumin _loc " " - e | " . " ; - e = SELF -> mkumin _loc " . " - e ] | " apply " LEFTA [ e1 = SELF ; e2 = SELF -> <: expr < $ e1 $ $ e2 $ >> | " assert " ; e = SELF -> mkassert _loc e | " new " ; i = class_longident -> <: expr < new $ i $ >> | " lazy " ; e = SELF -> <: expr < lazy $ e $ >> ] | " label " NONA [ " " ; ~ i = a_LIDENT ; " " ; : e = SELF -> <: expr < ~ $ i $ : $ e $ >> | " " ; ~ i = a_LIDENT -> <: expr < ~ $ i $ >> | ` LABEL i ; e = SELF -> <: expr < ~ $ i $ : $ e $ >> | ` OPTLABEL i ; e = SELF -> <: expr < ? $ i $ : $ e $ >> | " " ; ? i = a_LIDENT ; " " ; : e = SELF -> <: expr < ? $ i $ : $ e $ >> | " " ; ? i = a_LIDENT -> <: expr < ? $ i $ >> ] | " . " LEFTA [ e1 = SELF ; " . " ; " ( " ; e2 = SELF ; " ) " -> <: expr < $ e1 $ . ( $ e2 $ ) >> | e1 = SELF ; " . " ; " [ " ; e2 = SELF ; " ] " -> <: expr < $ e1 $ . [ $ e2 $ ] >> | e1 = SELF ; " . " ; " { " ; e2 = comma_expr ; " } " -> bigarray_get _loc e1 e2 | e1 = SELF ; " . " ; e2 = SELF -> <: expr < $ e1 $ . $ e2 $ >> | e = SELF ; " " ; # lab = label -> <: expr < $ e $ # $ lab $ >> ] | " " ~- NONA [ " " ; ! e = SELF -> <: expr < $ e . $ val >> | f = prefixop ; e = SELF -> <: expr < $ f $ $ e $ >> ] | " simple " [ ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . expr_tag | ` ANTIQUOT ( " exp " " " " || anti " as n ) s -> <: expr < $ anti : mk_anti ~ c " : expr " n s $ >> | ` ANTIQUOT ( " ` bool " as n ) s -> <: expr < $ id :<: ident < $ anti : mk_anti n s $ >>$ >> | ` ANTIQUOT ( " tup " as n ) s -> <: expr < $ tup : <: expr < $ anti : mk_anti ~ c " : expr " n s $ >>$ >> | ` ANTIQUOT ( " seq " as n ) s -> <: expr < do $ anti : mk_anti ~ c " : expr " n s $ done >> | s = a_INT -> <: expr < $ int : s $ >> | s = a_INT32 -> <: expr < $ int32 : s $ >> | s = a_INT64 -> <: expr < $ int64 : s $ >> | s = a_NATIVEINT -> <: expr < $ nativeint : s $ >> | s = a_FLOAT -> <: expr < $ flo : s $ >> | s = a_STRING -> <: expr < $ str : s $ >> | s = a_CHAR -> <: expr < $ chr : s $ >> | i = TRY module_longident_dot_lparen ; e = sequence ; " ) " -> <: expr < let open $ i $ in $ e $ >> | i = TRY val_longident -> <: expr < $ id : i $ >> | " ` " ; s = a_ident -> <: expr < ` $ s $ >> | " [ " ; " ] " -> <: expr < [ ] >> | " [ " ; mk_list = sem_expr_for_list ; " " ; :: last = expr ; " ] " -> mk_list last | " [ " ; mk_list = sem_expr_for_list ; " ] " -> mk_list <: expr < [ ] >> | " [ " ; | " ] " | -> <: expr < [ | $<: expr <>>$ ] | >> | " [ " ; | el = sem_expr ; " ] " | -> <: expr < [ | $ el $ ] | >> | " { " ; el = label_expr_list ; " } " -> <: expr < { $ el $ } >> | " { " ; " ( " ; e = SELF ; " ) " ; " with " ; el = label_expr_list ; " } " -> <: expr < { ( $ e ) $ with $ el $ } >> | " { " ; < " } " > -> <: expr < { } <> >> | " { " ; < fel = field_expr_list ; " } " > -> <: expr < { < $ fel $ } > >> | " ( " ; " ) " -> <: expr < ( ) >> | " ( " ; e = SELF ; " " ; : t = ctyp ; " ) " -> <: expr < ( $ e $ : $ t ) $ >> | " ( " ; e = SELF ; " , " ; el = comma_expr ; " ) " -> <: expr < ( $ e , $ $ el $ ) >> | " ( " ; e = SELF ; " ; " ; seq = sequence ; " ) " -> mksequence _loc <: expr < $ e ; $ $ seq $ >> | " ( " ; e = SELF ; " ; " ; " ) " -> mksequence _loc e | " ( " ; e = SELF ; " " ; : t = ctyp ; " " ; :> t2 = ctyp ; " ) " -> <: expr < ( $ e $ : $ t $ :> $ t2 $ ) >> | " ( " ; e = SELF ; " " ; :> t = ctyp ; " ) " -> <: expr < ( $ e $ :> $ t ) $ >> | " ( " ; e = SELF ; " ) " -> e | " begin " ; seq = sequence ; " end " -> mksequence _loc seq | " begin " ; " end " -> <: expr < ( ) >> | " ( " ; " module " ; me = module_expr ; " ) " -> <: expr < ( module $ me ) $ >> | " ( " ; " module " ; me = module_expr ; " " ; : pt = package_type ; " ) " -> <: expr < ( module $ me $ : $ pt ) $ >> ] ] ; do_sequence : [ [ seq = TRY [ " { " ; seq = sequence ; " } " -> seq ] -> seq | TRY [ " { " ; " } " ] -> <: expr < ( ) >> | seq = TRY [ seq = sequence ; " done " -> seq ] -> seq | " done " -> <: expr < ( ) >> ] ] ; infixop5 : [ [ x = [ " " & | " " && ] -> <: expr < $ lid : x $ >> ] ] ; infixop6 : [ [ x = [ " or " | " " || ] -> <: expr < $ lid : x $ >> ] ] ; sem_expr_for_list : [ [ e = expr ; " ; " ; el = SELF -> fun acc -> <: expr < [ $ e $ :: $ el acc $ ] >> | e = expr ; " ; " -> fun acc -> <: expr < [ $ e $ :: $ acc $ ] >> | e = expr -> fun acc -> <: expr < [ $ e $ :: $ acc $ ] >> ] ] ; comma_expr : [ [ e1 = SELF ; " , " ; e2 = SELF -> <: expr < $ e1 , $ $ e2 $ >> | ` ANTIQUOT ( " list " as n ) s -> <: expr < $ anti : mk_anti ~ c " : expr , " n s $ >> | e = expr LEVEL " top " -> e ] ] ; dummy : [ [ -> ( ) ] ] ; sequence ' : [ [ -> fun e -> e | " ; " -> fun e -> e | " ; " ; el = sequence -> fun e -> <: expr < $ e ; $ $ el $ >> ] ] ; sequence : [ [ " let " ; rf = opt_rec ; bi = binding ; " in " ; e = expr ; k = sequence ' -> k <: expr < let $ rec : rf $ $ bi $ in $ e $ >> | " let " ; rf = opt_rec ; bi = binding ; " ; " ; el = SELF -> <: expr < let $ rec : rf $ $ bi $ in $ mksequence _loc el $ >> | " let " ; " module " ; m = a_UIDENT ; mb = module_binding0 ; " in " ; e = expr ; k = sequence ' -> k <: expr < let module $ m $ = $ mb $ in $ e $ >> | " let " ; " module " ; m = a_UIDENT ; mb = module_binding0 ; " ; " ; el = SELF -> <: expr < let module $ m $ = $ mb $ in $ mksequence _loc el $ >> | " let " ; " open " ; i = module_longident ; " in " ; e = SELF -> <: expr < let open $ id : i $ in $ e $ >> | ` ANTIQUOT ( " list " as n ) s -> <: expr < $ anti : mk_anti ~ c " : expr ; " n s $ >> | e = expr ; k = sequence ' -> k e ] ] ; binding : [ LEFTA [ ` ANTIQUOT ( " binding " " | list " as n ) s -> <: binding < $ anti : mk_anti ~ c " : binding " n s $ >> | ` ANTIQUOT ( " " " | anti " as n ) s ; " " ; = e = expr -> <: binding < $ anti : mk_anti ~ c " : patt " n s $ = $ e $ >> | ` ANTIQUOT ( " " " | anti " as n ) s -> <: binding < $ anti : mk_anti ~ c " : binding " n s $ >> | b1 = SELF ; " and " ; b2 = SELF -> <: binding < $ b1 $ and $ b2 $ >> | b = let_binding -> b ] ] ; let_binding : [ [ p = ipatt ; e = fun_binding -> <: binding < $ p $ = $ e $ >> ] ] ; fun_binding : [ RIGHTA [ TRY [ " ( " ; " type " ] ; i = a_LIDENT ; " ) " ; e = SELF -> <: expr < fun ( type $ i ) $ -> $ e $ >> | p = TRY labeled_ipatt ; e = SELF -> <: expr < fun $ p $ -> $ e $ >> | bi = cvalue_binding -> bi ] ] ; match_case : [ [ " [ " ; l = LIST0 match_case0 SEP " " ; | " ] " -> Ast . mcOr_of_list l | p = ipatt ; " " ; -> e = expr -> <: match_case < $ p $ -> $ e $ >> ] ] ; match_case0 : [ [ ` ANTIQUOT ( " match_case " " | list " as n ) s -> <: match_case < $ anti : mk_anti ~ c " : match_case " n s $ >> | ` ANTIQUOT ( " " " | anti " as n ) s -> <: match_case < $ anti : mk_anti ~ c " : match_case " n s $ >> | ` ANTIQUOT ( " " " | anti " as n ) s ; " " ; -> e = expr -> <: match_case < $ anti : mk_anti ~ c " : patt " n s $ -> $ e $ >> | ` ANTIQUOT ( " " " | anti " as n ) s ; " when " ; w = expr ; " " ; -> e = expr -> <: match_case < $ anti : mk_anti ~ c " : patt " n s $ when $ w $ -> $ e $ >> | p = patt_as_patt_opt ; w = opt_when_expr ; " " ; -> e = expr -> <: match_case < $ p $ when $ w $ -> $ e $ >> ] ] ; opt_when_expr : [ [ " when " ; w = expr -> w | -> <: expr <>> ] ] ; patt_as_patt_opt : [ [ p1 = patt ; " as " ; p2 = patt -> <: patt < ( $ p1 $ as $ p2 ) $ >> | p = patt -> p ] ] ; label_expr_list : [ [ b1 = label_expr ; " ; " ; b2 = SELF -> <: rec_binding < $ b1 $ ; $ b2 $ >> | b1 = label_expr ; " ; " -> b1 | b1 = label_expr -> b1 ] ] ; label_expr : [ [ ` ANTIQUOT ( " rec_binding " as n ) s -> <: rec_binding < $ anti : mk_anti ~ c " : rec_binding " n s $ >> | ` ANTIQUOT ( " " " | anti " as n ) s -> <: rec_binding < $ anti : mk_anti ~ c " : rec_binding " n s $ >> | ` ANTIQUOT ( " " " | anti " as n ) s ; " " ; = e = expr -> <: rec_binding < $ anti : mk_anti ~ c " : ident " n s $ = $ e $ >> | ` ANTIQUOT ( " list " as n ) s -> <: rec_binding < $ anti : mk_anti ~ c " : rec_binding " n s $ >> | i = label_longident ; e = fun_binding -> <: rec_binding < $ i $ = $ e $ >> | i = label_longident -> <: rec_binding < $ i $ = $ lid : lid_of_ident i $ >> ] ] ; fun_def : [ [ TRY [ " ( " ; " type " ] ; i = a_LIDENT ; " ) " ; e = fun_def_cont_no_when -> <: expr < fun ( type $ i ) $ -> $ e $ >> | p = TRY labeled_ipatt ; ( w , e ) = fun_def_cont -> <: expr < fun [ $ p $ when $ w $ -> $ e $ ] >> ] ] ; fun_def_cont : [ RIGHTA [ TRY [ " ( " ; " type " ] ; i = a_LIDENT ; " ) " ; e = fun_def_cont_no_when -> ( <: expr , <>> <: expr < fun ( type $ i ) $ -> $ e $ ) >> | p = TRY labeled_ipatt ; ( w , e ) = SELF -> ( <: expr , <>> <: expr < fun [ $ p $ when $ w $ -> $ e $ ] ) >> | " when " ; w = expr ; " " ; -> e = expr -> ( w , e ) | " " ; -> e = expr -> ( <: expr , <>> e ) ] ] ; fun_def_cont_no_when : [ RIGHTA [ TRY [ " ( " ; " type " ] ; i = a_LIDENT ; " ) " ; e = fun_def_cont_no_when -> <: expr < fun ( type $ i ) $ -> $ e $ >> | p = TRY labeled_ipatt ; ( w , e ) = fun_def_cont -> <: expr < fun [ $ p $ when $ w $ -> $ e $ ] >> | " " ; -> e = expr -> e ] ] ; patt : [ " " | LEFTA [ p1 = SELF ; " " ; | p2 = SELF -> <: patt < $ p1 $ | $ p2 $ >> ] | " . . " NONA [ p1 = SELF ; " . . " ; p2 = SELF -> <: patt < $ p1 $ . . $ p2 $ >> ] | " apply " LEFTA [ p1 = SELF ; p2 = SELF -> <: patt < $ p1 $ $ p2 $ >> | " lazy " ; p = SELF -> <: patt < lazy $ p $ >> ] | " simple " [ ` ANTIQUOT ( " " " | pat " " | anti " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt " n s $ >> | ` ANTIQUOT ( " tup " as n ) s -> <: patt < ( $ tup :<: patt < $ anti : mk_anti ~ c " : patt " n s $ ) >>$ >> | ` ANTIQUOT ( " ` bool " as n ) s -> <: patt < $ id :<: ident < $ anti : mk_anti n s $ >>$ >> | i = ident -> <: patt < $ id : i $ >> | s = a_INT -> <: patt < $ int : s $ >> | s = a_INT32 -> <: patt < $ int32 : s $ >> | s = a_INT64 -> <: patt < $ int64 : s $ >> | s = a_NATIVEINT -> <: patt < $ nativeint : s $ >> | s = a_FLOAT -> <: patt < $ flo : s $ >> | s = a_STRING -> <: patt < $ str : s $ >> | s = a_CHAR -> <: patt < $ chr : s $ >> | " " ; - s = a_INT -> <: patt < $ int : neg_string s $ >> | " " ; - s = a_INT32 -> <: patt < $ int32 : neg_string s $ >> | " " ; - s = a_INT64 -> <: patt < $ int64 : neg_string s $ >> | " " ; - s = a_NATIVEINT -> <: patt < $ nativeint : neg_string s $ >> | " " ; - s = a_FLOAT -> <: patt < $ flo : neg_string s $ >> | " [ " ; " ] " -> <: patt < [ ] >> | " [ " ; mk_list = sem_patt_for_list ; " " ; :: last = patt ; " ] " -> mk_list last | " [ " ; mk_list = sem_patt_for_list ; " ] " -> mk_list <: patt < [ ] >> | " [ " ; | " ] " | -> <: patt < [ | $<: patt <>>$ ] | >> | " [ " ; | pl = sem_patt ; " ] " | -> <: patt < [ | $ pl $ ] | >> | " { " ; pl = label_patt_list ; " } " -> <: patt < { $ pl $ } >> | " ( " ; " ) " -> <: patt < ( ) >> | " ( " ; p = SELF ; " ) " -> p | " ( " ; p = SELF ; " " ; : t = ctyp ; " ) " -> <: patt < ( $ p $ : $ t ) $ >> | " ( " ; p = SELF ; " as " ; p2 = SELF ; " ) " -> <: patt < ( $ p $ as $ p2 ) $ >> | " ( " ; p = SELF ; " , " ; pl = comma_patt ; " ) " -> <: patt < ( $ p , $ $ pl ) $ >> | " _ " -> <: patt < _ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . patt_tag | " ` " ; s = a_ident -> <: patt < ` $ s $ >> | " " ; # i = type_longident -> <: patt < # $ i $ >> | ` LABEL i ; p = SELF -> <: patt < ~ $ i $ : $ p $ >> | " " ; ~ ` ANTIQUOT ( " " " | lid " as n ) i ; " " ; : p = SELF -> <: patt < ~ $ mk_anti n i $ : $ p $ >> | " " ; ~ ` ANTIQUOT ( " " " | lid " as n ) i -> <: patt < ~ $ mk_anti n i $ >> | " " ; ~ ` LIDENT i -> <: patt < ~ $ i $ >> | ` OPTLABEL i ; " ( " ; p = patt_tcon ; f = eq_expr ; " ) " -> f i p | " " ; ? ` ANTIQUOT ( " " " | lid " as n ) i ; " " ; : " ( " ; p = patt_tcon ; f = eq_expr ; " ) " -> f ( mk_anti n i ) p | " " ; ? ` LIDENT i -> <: patt < ? $ i $ >> | " " ; ? ` ANTIQUOT ( " " " | lid " as n ) i -> <: patt < ? $ mk_anti n i $ >> | " " ; ? " ( " ; p = patt_tcon ; " ) " -> <: patt < ? ( $ p ) $ >> | " " ; ? " ( " ; p = patt_tcon ; " " ; = e = expr ; " ) " -> <: patt < ? ( $ p $ = $ e ) $ >> ] ] ; comma_patt : [ [ p1 = SELF ; " , " ; p2 = SELF -> <: patt < $ p1 , $ $ p2 $ >> | ` ANTIQUOT ( " list " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt , " n s $ >> | p = patt -> p ] ] ; sem_patt : [ LEFTA [ p1 = patt ; " ; " ; p2 = SELF -> <: patt < $ p1 ; $ $ p2 $ >> | ` ANTIQUOT ( " list " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt ; " n s $ >> | p = patt ; " ; " -> p | p = patt -> p ] ] ; sem_patt_for_list : [ [ p = patt ; " ; " ; pl = SELF -> fun acc -> <: patt < [ $ p $ :: $ pl acc $ ] >> | p = patt ; " ; " -> fun acc -> <: patt < [ $ p $ :: $ acc $ ] >> | p = patt -> fun acc -> <: patt < [ $ p $ :: $ acc $ ] >> ] ] ; label_patt_list : [ [ p1 = label_patt ; " ; " ; p2 = SELF -> <: patt < $ p1 $ ; $ p2 $ >> | p1 = label_patt ; " ; " ; " _ " -> <: patt < $ p1 $ ; _ >> | p1 = label_patt ; " ; " ; " _ " ; " ; " -> <: patt < $ p1 $ ; _ >> | p1 = label_patt ; " ; " -> p1 | p1 = label_patt -> p1 ] ] ; label_patt : [ [ ` ANTIQUOT ( " " " | pat " " | anti " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . patt_tag | ` ANTIQUOT ( " list " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt ; " n s $ >> | i = label_longident ; " " ; = p = patt -> <: patt < $ i $ = $ p $ >> | i = label_longident -> <: patt < $ i $ = $ lid : lid_of_ident i $ >> ] ] ; ipatt : [ [ " { " ; pl = label_ipatt_list ; " } " -> <: patt < { $ pl $ } >> | ` ANTIQUOT ( " " " | pat " " | anti " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt " n s $ >> | ` ANTIQUOT ( " tup " as n ) s -> <: patt < ( $ tup :<: patt < $ anti : mk_anti ~ c " : patt " n s $ ) >>$ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . patt_tag | " ( " ; " ) " -> <: patt < ( ) >> | " ( " ; p = SELF ; " ) " -> p | " ( " ; p = SELF ; " " ; : t = ctyp ; " ) " -> <: patt < ( $ p $ : $ t ) $ >> | " ( " ; p = SELF ; " as " ; p2 = SELF ; " ) " -> <: patt < ( $ p $ as $ p2 ) $ >> | " ( " ; p = SELF ; " , " ; pl = comma_ipatt ; " ) " -> <: patt < ( $ p , $ $ pl ) $ >> | s = a_LIDENT -> <: patt < $ lid : s $ >> | " _ " -> <: patt < _ >> ] ] ; labeled_ipatt : [ [ p = ipatt -> p ] ] ; comma_ipatt : [ LEFTA [ p1 = SELF ; " , " ; p2 = SELF -> <: patt < $ p1 , $ $ p2 $ >> | ` ANTIQUOT ( " list " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt , " n s $ >> | p = ipatt -> p ] ] ; label_ipatt_list : [ [ p1 = label_ipatt ; " ; " ; p2 = SELF -> <: patt < $ p1 $ ; $ p2 $ >> | p1 = label_ipatt ; " ; " -> p1 | p1 = label_ipatt -> p1 ] ] ; label_ipatt : [ [ ` ANTIQUOT ( " " " | pat " " | anti " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt " n s $ >> | ` ANTIQUOT ( " list " as n ) s -> <: patt < $ anti : mk_anti ~ c " : patt ; " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . patt_tag | i = label_longident ; " " ; = p = ipatt -> <: patt < $ i $ = $ p $ >> ] ] ; type_declaration : [ LEFTA [ ` ANTIQUOT ( " " " | typ " " | anti " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctypand " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | t1 = SELF ; " and " ; t2 = SELF -> <: ctyp < $ t1 $ and $ t2 $ >> | ( n , tpl ) = type_ident_and_parameters ; tk = opt_eq_ctyp ; cl = LIST0 constrain -> Ast . TyDcl _loc n tpl tk cl ] ] ; constrain : [ [ " constraint " ; t1 = ctyp ; " " ; = t2 = ctyp -> ( t1 , t2 ) ] ] ; opt_eq_ctyp : [ [ " " ; = tk = type_kind -> tk | -> <: ctyp <>> ] ] ; type_kind : [ [ t = ctyp -> t ] ] ; type_ident_and_parameters : [ [ i = a_LIDENT ; tpl = LIST0 type_parameter -> ( i , tpl ) ] ] ; type_longident_and_parameters : [ [ i = type_longident ; tpl = type_parameters -> tpl <: ctyp < $ id : i $ >> ] ] ; type_parameters : [ [ t1 = type_parameter ; t2 = SELF -> fun acc -> t2 <: ctyp < $ acc $ $ t1 $ >> | t = type_parameter -> fun acc -> <: ctyp < $ acc $ $ t $ >> | -> fun t -> t ] ] ; type_parameter : [ [ ` ANTIQUOT ( " " " | typ " " | anti " as n ) s -> <: ctyp < $ anti : mk_anti n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | " ' " ; i = a_ident -> <: ctyp < ' $ lid : i $ >> | " " ; + " ' " ; i = a_ident -> <: ctyp < ' +$ lid : i $ >> | " " ; - " ' " ; i = a_ident -> <: ctyp < ' -$ lid : i $ >> ] ] ; ctyp : [ " " == LEFTA [ t1 = SELF ; " " ; == t2 = SELF -> <: ctyp < $ t1 $ == $ t2 $ >> ] | " private " NONA [ " private " ; t = ctyp LEVEL " alias " -> <: ctyp < private $ t $ >> ] | " alias " LEFTA [ t1 = SELF ; " as " ; t2 = SELF -> <: ctyp < $ t1 $ as $ t2 $ >> ] | " forall " LEFTA [ " " ; ! t1 = typevars ; " . " ; t2 = ctyp -> <: ctyp < ! $ t1 $ . $ t2 $ >> ] | " arrow " RIGHTA [ t1 = SELF ; " " ; -> t2 = SELF -> <: ctyp < $ t1 $ -> $ t2 $ >> ] | " label " NONA [ " " ; ~ i = a_LIDENT ; " " ; : t = SELF -> <: ctyp < ~ $ i $ : $ t $ >> | i = a_LABEL ; t = SELF -> <: ctyp < ~ $ i $ : $ t $ >> | " " ; ? i = a_LIDENT ; " " ; : t = SELF -> <: ctyp < ? $ i $ : $ t $ >> | i = a_OPTLABEL ; t = SELF -> <: ctyp < ? $ i $ : $ t $ >> ] | " apply " LEFTA [ t1 = SELF ; t2 = SELF -> let t = <: ctyp < $ t1 $ $ t2 $ >> in try <: ctyp < $ id : Ast . ident_of_ctyp t $ >> with [ Invalid_argument _ -> t ] ] | " . " LEFTA [ t1 = SELF ; " . " ; t2 = SELF -> try <: ctyp < $ id : Ast . ident_of_ctyp t1 . $$ id : Ast . ident_of_ctyp t2 $ >> with [ Invalid_argument s -> raise ( Stream . Error s ) ] ] | " simple " [ " ' " ; i = a_ident -> <: ctyp < ' $ i $ >> | " _ " -> <: ctyp < _ >> | ` ANTIQUOT ( " " " | typ " " | anti " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` ANTIQUOT ( " tup " as n ) s -> <: ctyp < ( $ tup :<: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ ) >>$ >> | ` ANTIQUOT ( " id " as n ) s -> <: ctyp < $ id :<: ident < $ anti : mk_anti ~ c " : ident " n s $ >>$ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | i = a_LIDENT -> <: ctyp < $ lid : i $ >> | i = a_UIDENT -> <: ctyp < $ uid : i $ >> | " ( " ; t = SELF ; " " ; * tl = star_ctyp ; " ) " -> <: ctyp < ( $ t $ * $ tl $ ) >> | " ( " ; t = SELF ; " ) " -> t | " [ " ; " ] " -> <: ctyp < [ ] >> | " [ " ; t = constructor_declarations ; " ] " -> <: ctyp < [ $ t $ ] >> | " [ " ; " " ; = rfl = row_field ; " ] " -> <: ctyp < [ = $ rfl $ ] >> | " [ " ; " " ; > " ] " -> <: ctyp < [ > $<: ctyp <>>$ ] >> | " [ " ; " " ; > rfl = row_field ; " ] " -> <: ctyp < [ > $ rfl $ ] >> | " [ " ; " " ; < rfl = row_field ; " ] " -> <: ctyp < [ < $ rfl $ ] >> | " [ " ; " " ; < rfl = row_field ; " " ; > ntl = name_tags ; " ] " -> <: ctyp < [ < $ rfl $ > $ ntl $ ] >> | " [ " ; < rfl = row_field ; " ] " -> <: ctyp < [ < $ rfl $ ] >> | " [ " ; < rfl = row_field ; " " ; > ntl = name_tags ; " ] " -> <: ctyp < [ < $ rfl $ > $ ntl $ ] >> | " { " ; t = label_declaration_list ; " } " -> <: ctyp < { $ t $ } >> | " " ; # i = class_longident -> <: ctyp < # $ i $ >> | " " ; < t = opt_meth_list ; " " > -> t | " ( " ; " module " ; p = package_type ; " ) " -> <: ctyp < ( module $ p ) $ >> ] ] ; star_ctyp : [ [ ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " * n s $ >> | t1 = SELF ; " " ; * t2 = SELF -> <: ctyp < $ t1 $ * $ t2 $ >> | t = ctyp -> t ] ] ; constructor_declarations : [ [ ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " | n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | t1 = SELF ; " " ; | t2 = SELF -> <: ctyp < $ t1 $ | $ t2 $ >> | s = a_UIDENT ; " of " ; t = constructor_arg_list -> <: ctyp < $ uid : s $ of $ t $ >> | s = a_UIDENT -> <: ctyp < $ uid : s $ >> ] ] ; constructor_declaration : [ [ ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | s = a_UIDENT ; " of " ; t = constructor_arg_list -> <: ctyp < $ uid : s $ of $ t $ >> | s = a_UIDENT -> <: ctyp < $ uid : s $ >> ] ] ; constructor_arg_list : [ [ ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctypand " n s $ >> | t1 = SELF ; " and " ; t2 = SELF -> <: ctyp < $ t1 $ and $ t2 $ >> | t = ctyp -> t ] ] ; label_declaration_list : [ [ t1 = label_declaration ; " ; " ; t2 = SELF -> <: ctyp < $ t1 ; $ $ t2 $ >> | t1 = label_declaration ; " ; " -> t1 | t1 = label_declaration -> t1 ] ] ; label_declaration : [ [ ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp ; " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | s = a_LIDENT ; " " ; : t = poly_type -> <: ctyp < $ lid : s $ : $ t $ >> | s = a_LIDENT ; " " ; : " mutable " ; t = poly_type -> <: ctyp < $ lid : s $ : mutable $ t $ >> ] ] ; a_ident : [ [ i = a_LIDENT -> i | i = a_UIDENT -> i ] ] ; ident : [ [ ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s -> <: ident < $ anti : mk_anti ~ c " : ident " n s $ >> | i = a_UIDENT -> <: ident < $ uid : i $ >> | i = a_LIDENT -> <: ident < $ lid : i $ >> | ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s ; " . " ; i = SELF -> <: ident < $ anti : mk_anti ~ c " : ident " n s . $$ i $ >> | i = a_UIDENT ; " . " ; j = SELF -> <: ident < $ uid : i . $$ j $ >> ] ] ; module_longident : [ [ ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s -> <: ident < $ anti : mk_anti ~ c " : ident " n s $ >> | m = a_UIDENT ; " . " ; l = SELF -> <: ident < $ uid : m . $$ l $ >> | i = a_UIDENT -> <: ident < $ uid : i $ >> ] ] ; module_longident_with_app : [ " apply " [ i = SELF ; j = SELF -> <: ident < $ i $ $ j $ >> ] | " . " [ i = SELF ; " . " ; j = SELF -> <: ident < $ i . $$ j $ >> ] | " simple " [ ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s -> <: ident < $ anti : mk_anti ~ c " : ident " n s $ >> | i = a_UIDENT -> <: ident < $ uid : i $ >> | " ( " ; i = SELF ; " ) " -> i ] ] ; module_longident_dot_lparen : [ [ ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s ; " . " ; " ( " -> <: ident < $ anti : mk_anti ~ c " : ident " n s $ >> | m = a_UIDENT ; " . " ; l = SELF -> <: ident < $ uid : m . $$ l $ >> | i = a_UIDENT ; " . " ; " ( " -> <: ident < $ uid : i $ >> ] ] ; type_longident : [ " apply " [ i = SELF ; j = SELF -> <: ident < $ i $ $ j $ >> ] | " . " [ i = SELF ; " . " ; j = SELF -> <: ident < $ i . $$ j $ >> ] | " simple " [ ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s -> <: ident < $ anti : mk_anti ~ c " : ident " n s $ >> | i = a_LIDENT -> <: ident < $ lid : i $ >> | i = a_UIDENT -> <: ident < $ uid : i $ >> | " ( " ; i = SELF ; " ) " -> i ] ] ; label_longident : [ [ ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s -> <: ident < $ anti : mk_anti ~ c " : ident " n s $ >> | m = a_UIDENT ; " . " ; l = SELF -> <: ident < $ uid : m . $$ l $ >> | i = a_LIDENT -> <: ident < $ lid : i $ >> ] ] ; class_type_longident : [ [ x = type_longident -> x ] ] ; val_longident : [ [ x = ident -> x ] ] ; class_longident : [ [ x = label_longident -> x ] ] ; class_declaration : [ LEFTA [ c1 = SELF ; " and " ; c2 = SELF -> <: class_expr < $ c1 $ and $ c2 $ >> | ` ANTIQUOT ( " " " | cdcl " " | anti " " | list " as n ) s -> <: class_expr < $ anti : mk_anti ~ c " : class_expr " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . class_expr_tag | ci = class_info_for_class_expr ; ce = class_fun_binding -> <: class_expr < $ ci $ = $ ce $ >> ] ] ; class_fun_binding : [ [ " " ; = ce = class_expr -> ce | " " ; : ct = class_type_plus ; " " ; = ce = class_expr -> <: class_expr < ( $ ce $ : $ ct ) $ >> | p = labeled_ipatt ; cfb = SELF -> <: class_expr < fun $ p $ -> $ cfb $ >> ] ] ; class_info_for_class_type : [ [ mv = opt_virtual ; ( i , ot ) = class_name_and_param -> <: class_type < $ virtual : mv $ $ lid : i $ [ $ ot $ ] >> ] ] ; class_info_for_class_expr : [ [ mv = opt_virtual ; ( i , ot ) = class_name_and_param -> <: class_expr < $ virtual : mv $ $ lid : i $ [ $ ot $ ] >> ] ] ; class_name_and_param : [ [ i = a_LIDENT ; " [ " ; x = comma_type_parameter ; " ] " -> ( i , x ) | i = a_LIDENT -> ( i , <: ctyp ) <>> ] ] ; comma_type_parameter : [ [ t1 = SELF ; " , " ; t2 = SELF -> <: ctyp < $ t1 , $ $ t2 $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp , " n s $ >> | t = type_parameter -> t ] ] ; opt_comma_ctyp : [ [ " [ " ; x = comma_ctyp ; " ] " -> x | -> <: ctyp <>> ] ] ; comma_ctyp : [ [ t1 = SELF ; " , " ; t2 = SELF -> <: ctyp < $ t1 , $ $ t2 $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp , " n s $ >> | t = ctyp -> t ] ] ; class_fun_def : [ [ p = labeled_ipatt ; ce = SELF -> <: class_expr < fun $ p $ -> $ ce $ >> | " " ; -> ce = class_expr -> ce ] ] ; class_expr : [ " top " [ " fun " ; p = labeled_ipatt ; ce = class_fun_def -> <: class_expr < fun $ p $ -> $ ce $ >> | " let " ; rf = opt_rec ; bi = binding ; " in " ; ce = SELF -> <: class_expr < let $ rec : rf $ $ bi $ in $ ce $ >> ] | " apply " NONA [ ce = SELF ; e = expr LEVEL " label " -> <: class_expr < $ ce $ $ e $ >> ] | " simple " [ ` ANTIQUOT ( " " " | cexp " " | anti " as n ) s -> <: class_expr < $ anti : mk_anti ~ c " : class_expr " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . class_expr_tag | ce = class_longident_and_param -> ce | " object " ; csp = opt_class_self_patt ; cst = class_structure ; " end " -> <: class_expr < object ( $ csp ) $ $ cst $ end >> | " ( " ; ce = SELF ; " " ; : ct = class_type ; " ) " -> <: class_expr < ( $ ce $ : $ ct ) $ >> | " ( " ; ce = SELF ; " ) " -> ce ] ] ; class_longident_and_param : [ [ ci = class_longident ; " [ " ; t = comma_ctyp ; " ] " -> <: class_expr < $ id : ci $ [ $ t $ ] >> | ci = class_longident -> <: class_expr < $ id : ci $ >> ] ] ; class_structure : [ [ ` ANTIQUOT ( " " " | cst " " | anti " " | list " as n ) s -> <: class_str_item < $ anti : mk_anti ~ c " : class_str_item " n s $ >> | ` ANTIQUOT ( " " " | cst " " | anti " " | list " as n ) s ; semi ; cst = SELF -> <: class_str_item < $ anti : mk_anti ~ c " : class_str_item " n s ; $ $ cst $ >> | l = LIST0 [ cst = class_str_item ; semi -> cst ] -> Ast . crSem_of_list l ] ] ; opt_class_self_patt : [ [ " ( " ; p = patt ; " ) " -> p | " ( " ; p = patt ; " " ; : t = ctyp ; " ) " -> <: patt < ( $ p $ : $ t ) $ >> | -> <: patt <>> ] ] ; class_str_item : [ LEFTA [ ` ANTIQUOT ( " " " | cst " " | anti " " | list " as n ) s -> <: class_str_item < $ anti : mk_anti ~ c " : class_str_item " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . class_str_item_tag | " inherit " ; o = opt_override ; ce = class_expr ; pb = opt_as_lident -> <: class_str_item < inherit $ override : o $ $ ce $ as $ pb $ >> | o = value_val_opt_override ; mf = opt_mutable ; lab = label ; e = cvalue_binding -> <: class_str_item < value $ override : o $ $ mutable : mf $ $ lab $ = $ e $ >> | o = value_val_opt_override ; mf = opt_mutable ; " virtual " ; l = label ; " " ; : t = poly_type -> if o <> <: override_flag <>> then raise ( Stream . Error " override ( ) ! is incompatible with virtual " ) else <: class_str_item < value virtual $ mutable : mf $ $ l $ : $ t $ >> | o = value_val_opt_override ; " virtual " ; mf = opt_mutable ; l = label ; " " ; : t = poly_type -> if o <> <: override_flag <>> then raise ( Stream . Error " override ( ) ! is incompatible with virtual " ) else <: class_str_item < value virtual $ mutable : mf $ $ l $ : $ t $ >> | o = method_opt_override ; " virtual " ; pf = opt_private ; l = label ; " " ; : t = poly_type -> if o <> <: override_flag <>> then raise ( Stream . Error " override ( ) ! is incompatible with virtual " ) else <: class_str_item < method virtual $ private : pf $ $ l $ : $ t $ >> | o = method_opt_override ; pf = opt_private ; l = label ; topt = opt_polyt ; e = fun_binding -> <: class_str_item < method $ override : o $ $ private : pf $ $ l $ : $ topt $ = $ e $ >> | o = method_opt_override ; pf = opt_private ; " virtual " ; l = label ; " " ; : t = poly_type -> if o <> <: override_flag <>> then raise ( Stream . Error " override ( ) ! is incompatible with virtual " ) else <: class_str_item < method virtual $ private : pf $ $ l $ : $ t $ >> | type_constraint ; t1 = ctyp ; " " ; = t2 = ctyp -> <: class_str_item < type $ t1 $ = $ t2 $ >> | " initializer " ; se = expr -> <: class_str_item < initializer $ se $ >> ] ] ; method_opt_override : [ [ " method " ; " " ! -> <: override_flag < ! >> | " method " ; ` ANTIQUOT ( ( " " " !| override " " | anti " ) as n ) s -> Ast . OvAnt ( mk_anti n s ) | " method " -> <: override_flag <>> ] ] ; value_val_opt_override : [ [ value_val ; " " ! -> <: override_flag < ! >> | value_val ; ` ANTIQUOT ( ( " " " !| override " " | anti " ) as n ) s -> Ast . OvAnt ( mk_anti n s ) | value_val -> <: override_flag <>> ] ] ; opt_as_lident : [ [ " as " ; i = a_LIDENT -> i | -> " " ] ] ; opt_polyt : [ [ " " ; : t = poly_type -> t | -> <: ctyp <>> ] ] ; cvalue_binding : [ [ " " ; = e = expr -> e | " " ; : t = poly_type ; " " ; = e = expr -> <: expr < ( $ e $ : $ t ) $ >> | " " ; : t = poly_type ; " " ; :> t2 = ctyp ; " " ; = e = expr -> match t with [ <: ctyp < ! $ _ $ . $ _ $ >> -> raise ( Stream . Error " unexpected polytype here " ) | _ -> <: expr < ( $ e $ : $ t $ :> $ t2 ) $ >> ] | " " ; :> t = ctyp ; " " ; = e = expr -> <: expr < ( $ e $ :> $ t ) $ >> ] ] ; label : [ [ i = a_LIDENT -> i ] ] ; class_type : [ [ ` ANTIQUOT ( " " " | ctyp " " | anti " as n ) s -> <: class_type < $ anti : mk_anti ~ c " : class_type " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . class_type_tag | ct = class_type_longident_and_param -> ct | " object " ; cst = opt_class_self_type ; csg = class_signature ; " end " -> <: class_type < object ( $ cst ) $ $ csg $ end >> ] ] ; class_type_longident_and_param : [ [ i = class_type_longident ; " [ " ; t = comma_ctyp ; " ] " -> <: class_type < $ id : i $ [ $ t $ ] >> | i = class_type_longident -> <: class_type < $ id : i $ >> ] ] ; class_type_plus : [ [ " [ " ; t = ctyp ; " ] " ; " " ; -> ct = SELF -> <: class_type < [ $ t $ ] -> $ ct $ >> | ct = class_type -> ct ] ] ; opt_class_self_type : [ [ " ( " ; t = ctyp ; " ) " -> t | -> <: ctyp <>> ] ] ; class_signature : [ [ ` ANTIQUOT ( " " " | csg " " | anti " " | list " as n ) s -> <: class_sig_item < $ anti : mk_anti ~ c " : class_sig_item " n s $ >> | ` ANTIQUOT ( " " " | csg " " | anti " " | list " as n ) s ; semi ; csg = SELF -> <: class_sig_item < $ anti : mk_anti ~ c " : class_sig_item " n s ; $ $ csg $ >> | l = LIST0 [ csg = class_sig_item ; semi -> csg ] -> Ast . cgSem_of_list l ] ] ; class_sig_item : [ [ ` ANTIQUOT ( " " " | csg " " | anti " " | list " as n ) s -> <: class_sig_item < $ anti : mk_anti ~ c " : class_sig_item " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . class_sig_item_tag | " inherit " ; cs = class_type -> <: class_sig_item < inherit $ cs $ >> | value_val ; mf = opt_mutable ; mv = opt_virtual ; l = label ; " " ; : t = ctyp -> <: class_sig_item < value $ mutable : mf $ $ virtual : mv $ $ l $ : $ t $ >> | " method " ; " virtual " ; pf = opt_private ; l = label ; " " ; : t = poly_type -> <: class_sig_item < method virtual $ private : pf $ $ l $ : $ t $ >> | " method " ; pf = opt_private ; l = label ; " " ; : t = poly_type -> <: class_sig_item < method $ private : pf $ $ l $ : $ t $ >> | " method " ; pf = opt_private ; " virtual " ; l = label ; " " ; : t = poly_type -> <: class_sig_item < method virtual $ private : pf $ $ l $ : $ t $ >> | type_constraint ; t1 = ctyp ; " " ; = t2 = ctyp -> <: class_sig_item < type $ t1 $ = $ t2 $ >> ] ] ; type_constraint : [ [ " type " | " constraint " -> ( ) ] ] ; class_description : [ [ cd1 = SELF ; " and " ; cd2 = SELF -> <: class_type < $ cd1 $ and $ cd2 $ >> | ` ANTIQUOT ( " " " | typ " " | anti " " | list " as n ) s -> <: class_type < $ anti : mk_anti ~ c " : class_type " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . class_type_tag | ci = class_info_for_class_type ; " " ; : ct = class_type_plus -> <: class_type < $ ci $ : $ ct $ >> ] ] ; class_type_declaration : [ LEFTA [ cd1 = SELF ; " and " ; cd2 = SELF -> <: class_type < $ cd1 $ and $ cd2 $ >> | ` ANTIQUOT ( " " " | typ " " | anti " " | list " as n ) s -> <: class_type < $ anti : mk_anti ~ c " : class_type " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . class_type_tag | ci = class_info_for_class_type ; " " ; = ct = class_type -> <: class_type < $ ci $ = $ ct $ >> ] ] ; field_expr_list : [ [ b1 = field_expr ; " ; " ; b2 = SELF -> <: rec_binding < $ b1 $ ; $ b2 $ >> | b1 = field_expr ; " ; " -> b1 | b1 = field_expr -> b1 ] ] ; field_expr : [ [ ` ANTIQUOT ( " " " | bi " " | anti " as n ) s -> <: rec_binding < $ anti : mk_anti ~ c " : rec_binding " n s $ >> | ` ANTIQUOT ( " list " as n ) s -> <: rec_binding < $ anti : mk_anti ~ c " : rec_binding " n s $ >> | l = label ; " " ; = e = expr LEVEL " top " -> <: rec_binding < $ lid : l $ = $ e $ >> ] ] ; meth_list : [ [ m = meth_decl ; " ; " ; ( ml , v ) = SELF -> ( <: ctyp < $ m ; $ $ ml $ , >> v ) | m = meth_decl ; " ; " ; v = opt_dot_dot -> ( m , v ) | m = meth_decl ; v = opt_dot_dot -> ( m , v ) ] ] ; meth_decl : [ [ ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp ; " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | lab = a_LIDENT ; " " ; : t = poly_type -> <: ctyp < $ lid : lab $ : $ t $ >> ] ] ; opt_meth_list : [ [ ( ml , v ) = meth_list -> <: ctyp < < $ ml $ . . $: v $ > >> | v = opt_dot_dot -> <: ctyp < < . . $: v $ > >> ] ] ; poly_type : [ [ t = ctyp -> t ] ] ; package_type : [ [ p = module_type -> p ] ] ; typevars : [ LEFTA [ t1 = SELF ; t2 = SELF -> <: ctyp < $ t1 $ $ t2 $ >> | ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` QUOTATION x -> Quotation . expand _loc x Quotation . DynAst . ctyp_tag | " ' " ; i = a_ident -> <: ctyp < ' $ lid : i $ >> ] ] ; row_field : [ [ ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " | n s $ >> | t1 = SELF ; " " ; | t2 = SELF -> <: ctyp < $ t1 $ | $ t2 $ >> | " ` " ; i = a_ident -> <: ctyp < ` $ i $ >> | " ` " ; i = a_ident ; " of " ; " " ; & t = amp_ctyp -> <: ctyp < ` $ i $ of & $ t $ >> | " ` " ; i = a_ident ; " of " ; t = amp_ctyp -> <: ctyp < ` $ i $ of $ t $ >> | t = ctyp -> t ] ] ; amp_ctyp : [ [ t1 = SELF ; " " ; & t2 = SELF -> <: ctyp < $ t1 $ & $ t2 $ >> | ` ANTIQUOT ( " list " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " & n s $ >> | t = ctyp -> t ] ] ; name_tags : [ [ ` ANTIQUOT ( " " " | typ " as n ) s -> <: ctyp < $ anti : mk_anti ~ c " : ctyp " n s $ >> | t1 = SELF ; t2 = SELF -> <: ctyp < $ t1 $ $ t2 $ >> | " ` " ; i = a_ident -> <: ctyp < ` $ i $ >> ] ] ; eq_expr : [ [ " " ; = e = expr -> fun i p -> <: patt < ? $ i $ : ( $ p $ = $ e ) $ >> | -> fun i p -> <: patt < ? $ i $ : ( $ p ) $ >> ] ] ; patt_tcon : [ [ p = patt ; " " ; : t = ctyp -> <: patt < ( $ p $ : $ t ) $ >> | p = patt -> p ] ] ; ipatt : [ [ ` LABEL i ; p = SELF -> <: patt < ~ $ i $ : $ p $ >> | " " ; ~ ` ANTIQUOT ( " " " | lid " as n ) i ; " " ; : p = SELF -> <: patt < ~ $ mk_anti n i $ : $ p $ >> | " " ; ~ ` ANTIQUOT ( " " " | lid " as n ) i -> <: patt < ~ $ mk_anti n i $ >> | " " ; ~ ` LIDENT i -> <: patt < ~ $ i $ >> | ` OPTLABEL i ; " ( " ; p = ipatt_tcon ; f = eq_expr ; " ) " -> f i p | " " ; ? ` ANTIQUOT ( " " " | lid " as n ) i ; " " ; : " ( " ; p = ipatt_tcon ; f = eq_expr ; " ) " -> f ( mk_anti n i ) p | " " ; ? ` LIDENT i -> <: patt < ? $ i $ >> | " " ; ? ` ANTIQUOT ( " " " | lid " as n ) i -> <: patt < ? $ mk_anti n i $ >> | " " ; ? " ( " ; p = ipatt_tcon ; " ) " -> <: patt < ? ( $ p ) $ >> | " " ; ? " ( " ; p = ipatt_tcon ; " " ; = e = expr ; " ) " -> <: patt < ? ( $ p $ = $ e ) $ >> ] ] ; ipatt_tcon : [ [ p = ipatt ; " " ; : t = ctyp -> <: patt < ( $ p $ : $ t ) $ >> | p = ipatt -> p ] ] ; direction_flag : [ [ " to " -> <: direction_flag < to >> | " downto " -> <: direction_flag < downto >> | ` ANTIQUOT ( " to " " | anti " as n ) s -> Ast . DiAnt ( mk_anti n s ) ] ] ; opt_private : [ [ " private " -> <: private_flag < private >> | ` ANTIQUOT ( " private " " | anti " as n ) s -> Ast . PrAnt ( mk_anti n s ) | -> <: private_flag <>> ] ] ; opt_mutable : [ [ " mutable " -> <: mutable_flag < mutable >> | ` ANTIQUOT ( " mutable " " | anti " as n ) s -> Ast . MuAnt ( mk_anti n s ) | -> <: mutable_flag <>> ] ] ; opt_virtual : [ [ " virtual " -> <: virtual_flag < virtual >> | ` ANTIQUOT ( " virtual " " | anti " as n ) s -> Ast . ViAnt ( mk_anti n s ) | -> <: virtual_flag <>> ] ] ; opt_dot_dot : [ [ " . . " -> <: row_var_flag < . . >> | ` ANTIQUOT ( " . . " " | anti " as n ) s -> Ast . RvAnt ( mk_anti n s ) | -> <: row_var_flag <>> ] ] ; opt_rec : [ [ " rec " -> <: rec_flag < rec >> | ` ANTIQUOT ( " rec " " | anti " as n ) s -> Ast . ReAnt ( mk_anti n s ) | -> <: rec_flag <>> ] ] ; opt_override : [ [ " " ! -> <: override_flag < ! >> | ` ANTIQUOT ( ( " " " !| override " " | anti " ) as n ) s -> Ast . OvAnt ( mk_anti n s ) | -> <: override_flag <>> ] ] ; opt_expr : [ [ e = expr -> e | -> <: expr <>> ] ] ; interf : [ [ " " ; # n = a_LIDENT ; dp = opt_expr ; semi -> ( [ <: sig_item < # $ n $ $ dp $ >> ] , stopped_at _loc ) | si = sig_item ; semi ; ( sil , stopped ) = SELF -> ( [ si :: sil ] , stopped ) | ` EOI -> ( [ ] , None ) ] ] ; sig_items : [ [ ` ANTIQUOT ( " " " | sigi " " | anti " " | list " as n ) s -> <: sig_item < $ anti : mk_anti n ~ c " : sig_item " s $ >> | ` ANTIQUOT ( " " " | sigi " " | anti " " | list " as n ) s ; semi ; sg = SELF -> <: sig_item < $ anti : mk_anti n ~ c " : sig_item " s ; $ $ sg $ >> | l = LIST0 [ sg = sig_item ; semi -> sg ] -> Ast . sgSem_of_list l ] ] ; implem : [ [ " " ; # n = a_LIDENT ; dp = opt_expr ; semi -> ( [ <: str_item < # $ n $ $ dp $ >> ] , stopped_at _loc ) | si = str_item ; semi ; ( sil , stopped ) = SELF -> ( [ si :: sil ] , stopped ) | ` EOI -> ( [ ] , None ) ] ] ; str_items : [ [ ` ANTIQUOT ( " " " | stri " " | anti " " | list " as n ) s -> <: str_item < $ anti : mk_anti n ~ c " : str_item " s $ >> | ` ANTIQUOT ( " " " | stri " " | anti " " | list " as n ) s ; semi ; st = SELF -> <: str_item < $ anti : mk_anti n ~ c " : str_item " s ; $ $ st $ >> | l = LIST0 [ st = str_item ; semi -> st ] -> Ast . stSem_of_list l ] ] ; top_phrase : [ [ ph = phrase -> Some ph | ` EOI -> None ] ] ; use_file : [ [ " " ; # n = a_LIDENT ; dp = opt_expr ; semi -> ( [ <: str_item < # $ n $ $ dp $ >> ] , stopped_at _loc ) | si = str_item ; semi ; ( sil , stopped ) = SELF -> ( [ si :: sil ] , stopped ) | ` EOI -> ( [ ] , None ) ] ] ; phrase : [ [ " " ; # n = a_LIDENT ; dp = opt_expr ; semi -> <: str_item < # $ n $ $ dp $ >> | st = str_item ; semi -> st ] ] ; a_INT : [ [ ` ANTIQUOT ( " " " | int " " ` | int " as n ) s -> mk_anti n s | ` INT _ s -> s ] ] ; a_INT32 : [ [ ` ANTIQUOT ( " " " | int32 " " ` | int32 " as n ) s -> mk_anti n s | ` INT32 _ s -> s ] ] ; a_INT64 : [ [ ` ANTIQUOT ( " " " | int64 " " ` | int64 " as n ) s -> mk_anti n s | ` INT64 _ s -> s ] ] ; a_NATIVEINT : [ [ ` ANTIQUOT ( " " " | nativeint " " ` | nativeint " as n ) s -> mk_anti n s | ` NATIVEINT _ s -> s ] ] ; a_FLOAT : [ [ ` ANTIQUOT ( " " " | flo " " ` | flo " as n ) s -> mk_anti n s | ` FLOAT _ s -> s ] ] ; a_CHAR : [ [ ` ANTIQUOT ( " " " | chr " " ` | chr " as n ) s -> mk_anti n s | ` CHAR _ s -> s ] ] ; a_UIDENT : [ [ ` ANTIQUOT ( " " " | uid " as n ) s -> mk_anti n s | ` UIDENT s -> s ] ] ; a_LIDENT : [ [ ` ANTIQUOT ( " " " | lid " as n ) s -> mk_anti n s | ` LIDENT s -> s ] ] ; a_LABEL : [ [ " " ; ~ ` ANTIQUOT ( " " as n ) s ; " " : -> mk_anti n s | ` LABEL s -> s ] ] ; a_OPTLABEL : [ [ " " ; ? ` ANTIQUOT ( " " as n ) s ; " " : -> mk_anti n s | ` OPTLABEL s -> s ] ] ; a_STRING : [ [ ` ANTIQUOT ( " " " | str " " ` | str " as n ) s -> mk_anti n s | ` STRING _ s -> s ] ] ; string_list : [ [ ` ANTIQUOT ( " " " | str_list " ) s -> Ast . LAnt ( mk_anti " str_list " s ) | ` STRING _ x ; xs = string_list -> Ast . LCons x xs | ` STRING _ x -> Ast . LCons x Ast . LNil ] ] ; value_let : [ [ " value " -> ( ) ] ] ; value_val : [ [ " value " -> ( ) ] ] ; semi : [ [ " ; " -> ( ) ] ] ; expr_quot : [ [ e1 = expr ; " , " ; e2 = comma_expr -> <: expr < $ e1 , $ $ e2 $ >> | e1 = expr ; " ; " ; e2 = sem_expr -> <: expr < $ e1 ; $ $ e2 $ >> | e = expr -> e | -> <: expr <>> ] ] ; patt_quot : [ [ x = patt ; " , " ; y = comma_patt -> <: patt < $ x , $ $ y $ >> | x = patt ; " ; " ; y = sem_patt -> <: patt < $ x ; $ $ y $ >> | x = patt ; " " ; = y = patt -> let i = match x with [ <: patt @ loc < $ anti : s $ >> -> <: ident @ loc < $ anti : s $ >> | p -> Ast . ident_of_patt p ] in <: patt < $ i $ = $ y $ >> | x = patt -> x | -> <: patt <>> ] ] ; ctyp_quot : [ [ x = more_ctyp ; " , " ; y = comma_ctyp -> <: ctyp < $ x , $ $ y $ >> | x = more_ctyp ; " ; " ; y = label_declaration_list -> <: ctyp < $ x ; $ $ y $ >> | x = more_ctyp ; " " ; | y = constructor_declarations -> <: ctyp < $ x $ | $ y $ >> | x = more_ctyp ; " of " ; y = constructor_arg_list -> <: ctyp < $ x $ of $ y $ >> | x = more_ctyp ; " of " ; y = constructor_arg_list ; " " ; | z = constructor_declarations -> <: ctyp < $ <: ctyp < $ x $ of $ y $ >> $ | $ z $ >> | x = more_ctyp ; " of " ; " " ; & y = amp_ctyp -> <: ctyp < $ x $ of & $ y $ >> | x = more_ctyp ; " of " ; " " ; & y = amp_ctyp ; " " ; | z = row_field -> <: ctyp < $ <: ctyp < $ x $ of & $ y $ >> $ | $ z $ >> | x = more_ctyp ; " " ; : y = more_ctyp -> <: ctyp < $ x $ : $ y $ >> | x = more_ctyp ; " " ; : y = more_ctyp ; " ; " ; z = label_declaration_list -> <: ctyp < $ <: ctyp < $ x $ : $ y $ >> $ ; $ z $ >> | x = more_ctyp ; " " ; * y = star_ctyp -> <: ctyp < $ x $ * $ y $ >> | x = more_ctyp ; " " ; & y = amp_ctyp -> <: ctyp < $ x $ & $ y $ >> | x = more_ctyp ; " and " ; y = constructor_arg_list -> <: ctyp < $ x $ and $ y $ >> | x = more_ctyp -> x | -> <: ctyp <>> ] ] ; more_ctyp : [ [ " mutable " ; x = SELF -> <: ctyp < mutable $ x $ >> | " ` " ; x = a_ident -> <: ctyp < ` $ x $ >> | x = ctyp -> x | x = type_parameter -> x ] ] ; str_item_quot : [ [ " " ; # n = a_LIDENT ; dp = opt_expr -> <: str_item < # $ n $ $ dp $ >> | st1 = str_item ; semi ; st2 = SELF -> <: str_item < $ st1 ; $ $ st2 $ >> | st = str_item -> st | -> <: str_item <>> ] ] ; sig_item_quot : [ [ " " ; # n = a_LIDENT ; dp = opt_expr -> <: sig_item < # $ n $ $ dp $ >> | sg1 = sig_item ; semi ; sg2 = SELF -> <: sig_item < $ sg1 ; $ $ sg2 $ >> | sg = sig_item -> sg | -> <: sig_item <>> ] ] ; module_type_quot : [ [ x = module_type -> x | -> <: module_type <>> ] ] ; module_expr_quot : [ [ x = module_expr -> x | -> <: module_expr <>> ] ] ; match_case_quot : [ [ x = LIST0 match_case0 SEP " " | -> <: match_case < $ list : x $ >> | -> <: match_case <>> ] ] ; binding_quot : [ [ x = binding -> x | -> <: binding <>> ] ] ; rec_binding_quot : [ [ x = label_expr_list -> x | -> <: rec_binding <>> ] ] ; module_binding_quot : [ [ b1 = SELF ; " and " ; b2 = SELF -> <: module_binding < $ b1 $ and $ b2 $ >> | ` ANTIQUOT ( " module_binding " " | anti " as n ) s -> <: module_binding < $ anti : mk_anti ~ c " : module_binding " n s $ >> | ` ANTIQUOT ( " " as n ) s -> <: module_binding < $ anti : mk_anti ~ c " : module_binding " n s $ >> | ` ANTIQUOT ( " " as n ) m ; " " ; : mt = module_type -> <: module_binding < $ mk_anti n m $ : $ mt $ >> | ` ANTIQUOT ( " " as n ) m ; " " ; : mt = module_type ; " " ; = me = module_expr -> <: module_binding < $ mk_anti n m $ : $ mt $ = $ me $ >> | m = a_UIDENT ; " " ; : mt = module_type -> <: module_binding < $ m $ : $ mt $ >> | m = a_UIDENT ; " " ; : mt = module_type ; " " ; = me = module_expr -> <: module_binding < $ m $ : $ mt $ = $ me $ >> | -> <: module_binding <>> ] ] ; ident_quot : [ " apply " [ i = SELF ; j = SELF -> <: ident < $ i $ $ j $ >> ] | " . " [ i = SELF ; " . " ; j = SELF -> <: ident < $ i . $$ j $ >> ] | " simple " [ ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s -> <: ident < $ anti : mk_anti ~ c " : ident " n s $ >> | i = a_UIDENT -> <: ident < $ uid : i $ >> | i = a_LIDENT -> <: ident < $ lid : i $ >> | ` ANTIQUOT ( " " " | id " " | anti " " | list " as n ) s ; " . " ; i = SELF -> <: ident < $ anti : mk_anti ~ c " : ident " n s . $$ i $ >> | " ( " ; i = SELF ; " ) " -> i ] ] ; class_expr_quot : [ [ ce1 = SELF ; " and " ; ce2 = SELF -> <: class_expr < $ ce1 $ and $ ce2 $ >> | ce1 = SELF ; " " ; = ce2 = SELF -> <: class_expr < $ ce1 $ = $ ce2 $ >> | " virtual " ; ( i , ot ) = class_name_and_param -> <: class_expr < virtual $ lid : i $ [ $ ot $ ] >> | ` ANTIQUOT ( " virtual " as n ) s ; i = ident ; ot = opt_comma_ctyp -> let anti = Ast . ViAnt ( mk_anti ~ c " : class_expr " n s ) in <: class_expr < $ virtual : anti $ $ id : i $ [ $ ot $ ] >> | x = class_expr -> x | -> <: class_expr <>> ] ] ; class_type_quot : [ [ ct1 = SELF ; " and " ; ct2 = SELF -> <: class_type < $ ct1 $ and $ ct2 $ >> | ct1 = SELF ; " " ; = ct2 = SELF -> <: class_type < $ ct1 $ = $ ct2 $ >> | ct1 = SELF ; " " ; : ct2 = SELF -> <: class_type < $ ct1 $ : $ ct2 $ >> | " virtual " ; ( i , ot ) = class_name_and_param -> <: class_type < virtual $ lid : i $ [ $ ot $ ] >> | ` ANTIQUOT ( " virtual " as n ) s ; i = ident ; ot = opt_comma_ctyp -> let anti = Ast . ViAnt ( mk_anti ~ c " : class_type " n s ) in <: class_type < $ virtual : anti $ $ id : i $ [ $ ot $ ] >> | x = class_type_plus -> x | -> <: class_type <>> ] ] ; class_str_item_quot : [ [ x1 = class_str_item ; semi ; x2 = SELF -> <: class_str_item < $ x1 ; $ $ x2 $ >> | x = class_str_item -> x | -> <: class_str_item <>> ] ] ; class_sig_item_quot : [ [ x1 = class_sig_item ; semi ; x2 = SELF -> <: class_sig_item < $ x1 ; $ $ x2 $ >> | x = class_sig_item -> x | -> <: class_sig_item <>> ] ] ; with_constr_quot : [ [ x = with_constr -> x | -> <: with_constr <>> ] ] ; rec_flag_quot : [ [ x = opt_rec -> x ] ] ; direction_flag_quot : [ [ x = direction_flag -> x ] ] ; mutable_flag_quot : [ [ x = opt_mutable -> x ] ] ; private_flag_quot : [ [ x = opt_private -> x ] ] ; virtual_flag_quot : [ [ x = opt_virtual -> x ] ] ; row_var_flag_quot : [ [ x = opt_dot_dot -> x ] ] ; override_flag_quot : [ [ x = opt_override -> x ] ] ; patt_eoi : [ [ x = patt ; ` EOI -> x ] ] ; expr_eoi : [ [ x = expr ; ` EOI -> x ] ] ; END ; end ; |
let module M = Register . OCamlSyntaxExtension Id Make in ( ) ; |
module Id : Sig . Id = struct value name = " Camlp4OCamlRevisedParserParser " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) = struct open Sig ; include Syntax ; type spat_comp = [ SpTrm of Loc . t and Ast . patt and option Ast . expr | SpNtr of Loc . t and Ast . patt and Ast . expr | SpStr of Loc . t and Ast . patt ] ; type sexp_comp = [ SeTrm of Loc . t and Ast . expr | SeNtr of Loc . t and Ast . expr ] ; value stream_expr = Gram . Entry . mk " stream_expr " ; value stream_begin = Gram . Entry . mk " stream_begin " ; value stream_end = Gram . Entry . mk " stream_end " ; value stream_quot = Gram . Entry . mk " stream_quot " ; value parser_case = Gram . Entry . mk " parser_case " ; value parser_case_list = Gram . Entry . mk " parser_case_list " ; value strm_n = " __strm " ; value peek_fun _loc = <: expr < Stream . peek ; >> value junk_fun _loc = <: expr < Stream . junk ; >> value rec pattern_eq_expression p e = match ( p , e ) with [ ( <: patt < $ lid : a $ , >> <: expr < $ lid : b $ ) >> -> a = b | ( <: patt < $ uid : a $ , >> <: expr < $ uid : b $ ) >> -> a = b | ( <: patt < $ p1 $ $ p2 $ , >> <: expr < $ e1 $ $ e2 $ ) >> -> pattern_eq_expression p1 e1 && pattern_eq_expression p2 e2 | _ -> False ] ; value is_raise e = match e with [ <: expr < raise $ _ $ >> -> True | _ -> False ] ; value is_raise_failure e = match e with [ <: expr < raise Stream . Failure >> -> True | _ -> False ] ; value rec handle_failure e = match e with [ <: expr < try $ _ $ with [ Stream . Failure -> $ e ] $ >> -> handle_failure e | <: expr < match $ me $ with [ $ a $ ] >> -> let rec match_case_handle_failure = fun [ <: match_case < $ a1 $ | $ a2 $ >> -> match_case_handle_failure a1 && match_case_handle_failure a2 | <: match_case < $ pat : _ $ -> $ e $ >> -> handle_failure e | _ -> False ] in handle_failure me && match_case_handle_failure a | <: expr < let $ bi $ in $ e $ >> -> let rec binding_handle_failure = fun [ <: binding < $ b1 $ and $ b2 $ >> -> binding_handle_failure b1 && binding_handle_failure b2 | <: binding < $ _ $ = $ e $ >> -> handle_failure e | _ -> False ] in binding_handle_failure bi && handle_failure e | <: expr < $ lid : _ $ >> | <: expr < $ int : _ $ >> | <: expr < $ str : _ $ >> | <: expr < $ chr : _ $ >> | <: expr < fun [ $ _ $ ] >> | <: expr < $ uid : _ $ >> -> True | <: expr < raise $ e $ >> -> match e with [ <: expr < Stream . Failure >> -> False | _ -> True ] | <: expr < $ f $ $ x $ >> -> is_constr_apply f && handle_failure f && handle_failure x | _ -> False ] and is_constr_apply = fun [ <: expr < $ uid : _ $ >> -> True | <: expr < $ lid : _ $ >> -> False | <: expr < $ x $ $ _ $ >> -> is_constr_apply x | _ -> False ] ; value rec subst v e = let _loc = Ast . loc_of_expr e in match e with [ <: expr < $ lid : x $ >> -> let x = if x = v then strm_n else x in <: expr < $ lid : x $ >> | <: expr < $ uid : _ $ >> -> e | <: expr < $ int : _ $ >> -> e | <: expr < $ chr : _ $ >> -> e | <: expr < $ str : _ $ >> -> e | <: expr < $ _ $ . $ _ $ >> -> e | <: expr < let $ rec : rf $ $ bi $ in $ e $ >> -> <: expr < let $ rec : rf $ $ subst_binding v bi $ in $ subst v e $ >> | <: expr < $ e1 $ $ e2 $ >> -> <: expr < $ subst v e1 $ $ subst v e2 $ >> | <: expr < ( $ tup : e $ ) >> -> <: expr < ( $ tup : subst v e $ ) >> | <: expr < $ e1 , $ $ e2 $ >> -> <: expr < $ subst v e1 , $ $ subst v e2 $ >> | _ -> raise Not_found ] and subst_binding v = fun [ <: binding @ _loc < $ b1 $ and $ b2 $ >> -> <: binding < $ subst_binding v b1 $ and $ subst_binding v b2 $ >> | <: binding @ _loc < $ lid : v ' $ = $ e $ >> -> <: binding < $ lid : v ' $ = $ if v = v ' then e else subst v e $ >> | _ -> raise Not_found ] ; value stream_pattern_component skont ckont = fun [ SpTrm _loc p None -> <: expr < match $ peek_fun _loc $ $ lid : strm_n $ with [ Some $ p $ -> do { $ junk_fun _loc $ $ lid : strm_n ; $ $ skont $ } | _ -> $ ckont $ ] >> | SpTrm _loc p ( Some w ) -> <: expr < match $ peek_fun _loc $ $ lid : strm_n $ with [ Some $ p $ when $ w $ -> do { $ junk_fun _loc $ $ lid : strm_n ; $ $ skont $ } | _ -> $ ckont $ ] >> | SpNtr _loc p e -> let e = match e with [ <: expr < fun [ ( $ lid : v $ : Stream . t _ ) -> $ e $ ] >> when v = strm_n -> e | _ -> <: expr < $ e $ $ lid : strm_n $ >> ] in if pattern_eq_expression p skont then if is_raise_failure ckont then e else if handle_failure e then e else <: expr < try $ e $ with [ Stream . Failure -> $ ckont $ ] >> else if is_raise_failure ckont then <: expr < let $ p $ = $ e $ in $ skont $ >> else if pattern_eq_expression <: patt < Some $ p $ >> skont then <: expr < try Some $ e $ with [ Stream . Failure -> $ ckont $ ] >> else if is_raise ckont then let tst = if handle_failure e then e else <: expr < try $ e $ with [ Stream . Failure -> $ ckont $ ] >> in <: expr < let $ p $ = $ tst $ in $ skont $ >> else <: expr < match try Some $ e $ with [ Stream . Failure -> None ] with [ Some $ p $ -> $ skont $ | _ -> $ ckont $ ] >> | SpStr _loc p -> try match p with [ <: patt < $ lid : v $ >> -> subst v skont | _ -> raise Not_found ] with [ Not_found -> <: expr < let $ p $ = $ lid : strm_n $ in $ skont $ >> ] ] ; value rec stream_pattern _loc epo e ekont = fun [ [ ] -> match epo with [ Some ep -> <: expr < let $ ep $ = Stream . count $ lid : strm_n $ in $ e $ >> | _ -> e ] | [ ( spc , err ) :: spcl ] -> let skont = let ekont err = let str = match err with [ Some estr -> estr | _ -> <: expr < " " >> ] in <: expr < raise ( Stream . Error $ str ) $ >> in stream_pattern _loc epo e ekont spcl in let ckont = ekont err in stream_pattern_component skont ckont spc ] ; value stream_patterns_term _loc ekont tspel = let pel = List . fold_right ( fun ( p , w , _loc , spcl , epo , e ) acc -> let p = <: patt < Some $ p $ >> in let e = let ekont err = let str = match err with [ Some estr -> estr | _ -> <: expr < " " >> ] in <: expr < raise ( Stream . Error $ str ) $ >> in let skont = stream_pattern _loc epo e ekont spcl in <: expr < do { $ junk_fun _loc $ $ lid : strm_n ; $ $ skont $ } >> in match w with [ Some w -> <: match_case < $ pat : p $ when $ w $ -> $ e $ | $ acc $ >> | None -> <: match_case < $ pat : p $ -> $ e $ | $ acc $ >> ] ) tspel <: match_case <>> in <: expr < match $ peek_fun _loc $ $ lid : strm_n $ with [ $ pel $ | _ -> $ ekont ( ) $ ] >> ; value rec group_terms = fun [ [ ( [ ( SpTrm _loc p w , None ) :: spcl ] , epo , e ) :: spel ] -> let ( tspel , spel ) = group_terms spel in ( [ ( p , w , _loc , spcl , epo , e ) :: tspel ] , spel ) | spel -> ( [ ] , spel ) ] ; value rec parser_cases _loc = fun [ [ ] -> <: expr < raise Stream . Failure >> | spel -> match group_terms spel with [ ( [ ] , [ ( spcl , epo , e ) :: spel ] ) -> stream_pattern _loc epo e ( fun _ -> parser_cases _loc spel ) spcl | ( tspel , spel ) -> stream_patterns_term _loc ( fun _ -> parser_cases _loc spel ) tspel ] ] ; value cparser _loc bpo pc = let e = parser_cases _loc pc in let e = match bpo with [ Some bp -> <: expr < let $ bp $ = Stream . count $ lid : strm_n $ in $ e $ >> | None -> e ] in let p = <: patt < ( $ lid : strm_n $ : Stream . t _ ) >> in <: expr < fun $ p $ -> $ e $ >> ; value cparser_match _loc me bpo pc = let pc = parser_cases _loc pc in let e = match bpo with [ Some bp -> <: expr < let $ bp $ = Stream . count $ lid : strm_n $ in $ pc $ >> | None -> pc ] in let me = match me with [ <: expr @ _loc < $ _ ; $ $ _ $ >> as e -> <: expr < do { $ e $ } >> | e -> e ] in match me with [ <: expr < $ lid : x $ >> when x = strm_n -> e | _ -> <: expr < let ( $ lid : strm_n $ : Stream . t _ ) = $ me $ in $ e $ >> ] ; value rec not_computing = fun [ <: expr < $ lid : _ $ >> | <: expr < $ uid : _ $ >> | <: expr < $ int : _ $ >> | <: expr < $ flo : _ $ >> | <: expr < $ chr : _ $ >> | <: expr < $ str : _ $ >> -> True | <: expr < $ x $ $ y $ >> -> is_cons_apply_not_computing x && not_computing y | _ -> False ] and is_cons_apply_not_computing = fun [ <: expr < $ uid : _ $ >> -> True | <: expr < $ lid : _ $ >> -> False | <: expr < $ x $ $ y $ >> -> is_cons_apply_not_computing x && not_computing y | _ -> False ] ; value slazy _loc e = match e with [ <: expr < $ f $ ( ) >> -> match f with [ <: expr < $ lid : _ $ >> -> f | _ -> <: expr < fun _ -> $ e $ >> ] | _ -> <: expr < fun _ -> $ e $ >> ] ; value rec cstream gloc = fun [ [ ] -> let _loc = gloc in <: expr < Stream . sempty >> | [ SeTrm _loc e ] -> if not_computing e then <: expr < Stream . ising $ e $ >> else <: expr < Stream . lsing $ slazy _loc e $ >> | [ SeTrm _loc e :: secl ] -> if not_computing e then <: expr < Stream . icons $ e $ $ cstream gloc secl $ >> else <: expr < Stream . lcons $ slazy _loc e $ $ cstream gloc secl $ >> | [ SeNtr _loc e ] -> if not_computing e then e else <: expr < Stream . slazy $ slazy _loc e $ >> | [ SeNtr _loc e :: secl ] -> if not_computing e then <: expr < Stream . iapp $ e $ $ cstream gloc secl $ >> else <: expr < Stream . lapp $ slazy _loc e $ $ cstream gloc secl $ >> ] ; EXTEND Gram GLOBAL : expr stream_expr stream_begin stream_end stream_quot parser_case parser_case_list ; expr : LEVEL " top " [ [ " parser " ; po = OPT parser_ipatt ; pcl = parser_case_list -> cparser _loc po pcl | " match " ; e = sequence ; " with " ; " parser " ; po = OPT parser_ipatt ; pcl = parser_case_list -> cparser_match _loc e po pcl ] ] ; parser_case_list : [ [ " [ " ; pcl = LIST0 parser_case SEP " " ; | " ] " -> pcl | pc = parser_case -> [ pc ] ] ] ; parser_case : [ [ stream_begin ; sp = stream_patt ; stream_end ; po = OPT parser_ipatt ; " " ; -> e = expr -> ( sp , po , e ) ] ] ; stream_begin : [ [ " [ " : -> ( ) ] ] ; stream_end : [ [ " ] " : -> ( ) ] ] ; stream_quot : [ [ " ` " -> ( ) ] ] ; stream_expr : [ [ e = expr -> e ] ] ; stream_patt : [ [ spc = stream_patt_comp -> [ ( spc , None ) ] | spc = stream_patt_comp ; " ; " ; sp = stream_patt_comp_err_list -> [ ( spc , None ) :: sp ] | -> [ ] ] ] ; stream_patt_comp_err : [ [ spc = stream_patt_comp ; eo = OPT [ " " ; ?? e = stream_expr -> e ] -> ( spc , eo ) ] ] ; stream_patt_comp_err_list : [ [ spc = stream_patt_comp_err -> [ spc ] | spc = stream_patt_comp_err ; " ; " -> [ spc ] | spc = stream_patt_comp_err ; " ; " ; sp = stream_patt_comp_err_list -> [ spc :: sp ] ] ] ; stream_patt_comp : [ [ stream_quot ; p = patt ; eo = OPT [ " when " ; e = stream_expr -> e ] -> SpTrm _loc p eo | p = patt ; " " ; = e = stream_expr -> SpNtr _loc p e | p = patt -> SpStr _loc p ] ] ; parser_ipatt : [ [ i = a_LIDENT -> <: patt < $ lid : i $ >> | " _ " -> <: patt < _ >> ] ] ; expr : LEVEL " simple " [ [ stream_begin ; stream_end -> <: expr < $ cstream _loc [ ] $ >> | stream_begin ; sel = stream_expr_comp_list ; stream_end -> <: expr < $ cstream _loc sel $ >> ] ] ; stream_expr_comp_list : [ [ se = stream_expr_comp ; " ; " ; sel = stream_expr_comp_list -> [ se :: sel ] | se = stream_expr_comp ; " ; " -> [ se ] | se = stream_expr_comp -> [ se ] ] ] ; stream_expr_comp : [ [ stream_quot ; e = stream_expr -> SeTrm _loc e | e = stream_expr -> SeNtr _loc e ] ] ; END ; end ; |
module M = Register . OCamlSyntaxExtension Id Make ; |
module Id = struct value name = " Camlp4Profiler " ; value version = Sys . ocaml_version ; end ; |
module Make ( AstFilters : Camlp4 . Sig . AstFilters ) = struct open AstFilters ; open Ast ; value decorate_binding decorate_fun = object inherit Ast . map as super ; method binding = fun [ <: binding @ _loc < $ lid : id $ = ( $<: expr < fun [ $ _ $ ] >> as e ) $ >> -> <: binding < $ lid : id $ = $ decorate_fun id e $ >> | b -> super # binding b ] ; end # binding ; value decorate decorate_fun = object ( o ) inherit Ast . map as super ; method str_item = fun [ <: str_item @ _loc < value $ rec : r $ $ b $ >> -> <: str_item < value $ rec : r $ $ decorate_binding decorate_fun b $ >> | st -> super # str_item st ] ; method expr = fun [ <: expr @ _loc < let $ rec : r $ $ b $ in $ e $ >> -> <: expr < let $ rec : r $ $ decorate_binding decorate_fun b $ in $ o # expr e $ >> | <: expr @ _loc < fun [ $ _ $ ] >> as e -> decorate_fun " < fun " > e | e -> super # expr e ] ; end ; value decorate_this_expr e id = let buf = Buffer . create 42 in let _loc = Ast . loc_of_expr e in let ( ) = Format . bprintf buf " % s @@ % a " @? id Loc . dump _loc in let s = Buffer . contents buf in <: expr < let ( ) = Camlp4prof . count ` $ str : s $ in $ e $ ; >> value rec decorate_fun id = let decorate = decorate decorate_fun in let decorate_expr = decorate # expr in let decorate_match_case = decorate # match_case in fun [ <: expr @ _loc < fun $ p $ -> $ e $ >> -> <: expr < fun $ p $ -> $ decorate_fun id e $ >> | <: expr @ _loc < fun [ $ m $ ] >> -> decorate_this_expr <: expr < fun [ $ decorate_match_case m $ ] >> id | e -> decorate_this_expr ( decorate_expr e ) id ] ; register_str_item_filter ( decorate decorate_fun ) # str_item ; end ; |
let module M = Camlp4 . Register . AstFilter Id Make in ( ) ; |
module Id = struct value name = " Camlp4QuotationCommon " ; value version = Sys . ocaml_version ; end ; |
module Make ( Syntax : Sig . Camlp4Syntax ) ( TheAntiquotSyntax : ( Sig . Parser Syntax . Ast ) . SIMPLE ) open Sig ; include Syntax ; module MetaLocHere = Ast . Meta . MetaLoc ; module MetaLoc = struct module Ast = Ast ; value loc_name = ref None ; value meta_loc_expr _loc loc = match loc_name . val with [ None -> <: expr < $ lid : Loc . name . val $ >> | Some " here " -> MetaLocHere . meta_loc_expr _loc loc | Some x -> <: expr < $ lid : x $ >> ] ; value meta_loc_patt _loc _ = <: patt < _ ; >> end ; module MetaAst = Ast . Meta . Make MetaLoc ; module ME = MetaAst . Expr ; module MP = MetaAst . Patt ; value is_antiquot s = let len = String . length s in len > 2 && s . [ 0 ] = ' ' \\ && s . [ 1 ] = ' ' ; $ value handle_antiquot_in_string s term parse loc decorate = if is_antiquot s then let pos = String . index s ' ' : in let name = String . sub s 2 ( pos - 2 ) and code = String . sub s ( pos + 1 ) ( String . length s - pos - 1 ) in decorate name ( parse loc code ) else term ; value antiquot_expander = object inherit Ast . map as super ; method patt = fun [ <: patt @ _loc < $ anti : s $ >> | <: patt @ _loc < $ str : s $ >> as p -> let mloc _loc = MetaLoc . meta_loc_patt _loc _loc in handle_antiquot_in_string s p TheAntiquotSyntax . parse_patt _loc ( fun n p -> match n with [ " antisig_item " -> <: patt < Ast . SgAnt $ mloc _loc $ $ p $ >> | " antistr_item " -> <: patt < Ast . StAnt $ mloc _loc $ $ p $ >> | " antictyp " -> <: patt < Ast . TyAnt $ mloc _loc $ $ p $ >> | " antipatt " -> <: patt < Ast . PaAnt $ mloc _loc $ $ p $ >> | " antiexpr " -> <: patt < Ast . ExAnt $ mloc _loc $ $ p $ >> | " antimodule_type " -> <: patt < Ast . MtAnt $ mloc _loc $ $ p $ >> | " antimodule_expr " -> <: patt < Ast . MeAnt $ mloc _loc $ $ p $ >> | " anticlass_type " -> <: patt < Ast . CtAnt $ mloc _loc $ $ p $ >> | " anticlass_expr " -> <: patt < Ast . CeAnt $ mloc _loc $ $ p $ >> | " anticlass_sig_item " -> <: patt < Ast . CgAnt $ mloc _loc $ $ p $ >> | " anticlass_str_item " -> <: patt < Ast . CrAnt $ mloc _loc $ $ p $ >> | " antiwith_constr " -> <: patt < Ast . WcAnt $ mloc _loc $ $ p $ >> | " antibinding " -> <: patt < Ast . BiAnt $ mloc _loc $ $ p $ >> | " antirec_binding " -> <: patt < Ast . RbAnt $ mloc _loc $ $ p $ >> | " antimatch_case " -> <: patt < Ast . McAnt $ mloc _loc $ $ p $ >> | " antimodule_binding " -> <: patt < Ast . MbAnt $ mloc _loc $ $ p $ >> | " antiident " -> <: patt < Ast . IdAnt $ mloc _loc $ $ p $ >> | _ -> p ] ) | p -> super # patt p ] ; method expr = fun [ <: expr @ _loc < $ anti : s $ >> | <: expr @ _loc < $ str : s $ >> as e -> let mloc _loc = MetaLoc . meta_loc_expr _loc _loc in handle_antiquot_in_string s e TheAntiquotSyntax . parse_expr _loc ( fun n e -> match n with [ " ` int " -> <: expr < string_of_int $ e $ >> | " ` int32 " -> <: expr < Int32 . to_string $ e $ >> | " ` int64 " -> <: expr < Int64 . to_string $ e $ >> | " ` nativeint " -> <: expr < Nativeint . to_string $ e $ >> | " ` flo " -> <: expr < Camlp4_import . Oprint . float_repres $ e $ >> | " ` str " -> <: expr < Ast . safe_string_escaped $ e $ >> | " ` chr " -> <: expr < Char . escaped $ e $ >> | " ` bool " -> <: expr < Ast . IdUid $ mloc _loc $ ( if $ e $ then " True " else " False " ) >> | " liststr_item " -> <: expr < Ast . stSem_of_list $ e $ >> | " listsig_item " -> <: expr < Ast . sgSem_of_list $ e $ >> | " listclass_sig_item " -> <: expr < Ast . cgSem_of_list $ e $ >> | " listclass_str_item " -> <: expr < Ast . crSem_of_list $ e $ >> | " listmodule_expr " -> <: expr < Ast . meApp_of_list $ e $ >> | " listmodule_type " -> <: expr < Ast . mtApp_of_list $ e $ >> | " listmodule_binding " -> <: expr < Ast . mbAnd_of_list $ e $ >> | " listbinding " -> <: expr < Ast . biAnd_of_list $ e $ >> | " listbinding ; " -> <: expr < Ast . biSem_of_list $ e $ >> | " listrec_binding " -> <: expr < Ast . rbSem_of_list $ e $ >> | " listclass_type " -> <: expr < Ast . ctAnd_of_list $ e $ >> | " listclass_expr " -> <: expr < Ast . ceAnd_of_list $ e $ >> | " listident " -> <: expr < Ast . idAcc_of_list $ e $ >> | " listctypand " -> <: expr < Ast . tyAnd_of_list $ e $ >> | " listctyp ; " -> <: expr < Ast . tySem_of_list $ e $ >> | " listctyp " * -> <: expr < Ast . tySta_of_list $ e $ >> | " listctyp " | -> <: expr < Ast . tyOr_of_list $ e $ >> | " listctyp , " -> <: expr < Ast . tyCom_of_list $ e $ >> | " listctyp " & -> <: expr < Ast . tyAmp_of_list $ e $ >> | " listwith_constr " -> <: expr < Ast . wcAnd_of_list $ e $ >> | " listmatch_case " -> <: expr < Ast . mcOr_of_list $ e $ >> | " listpatt , " -> <: expr < Ast . paCom_of_list $ e $ >> | " listpatt ; " -> <: expr < Ast . paSem_of_list $ e $ >> | " listexpr , " -> <: expr < Ast . exCom_of_list $ e $ >> | " listexpr ; " -> <: expr < Ast . exSem_of_list $ e $ >> | " antisig_item " -> <: expr < Ast . SgAnt $ mloc _loc $ $ e $ >> | " antistr_item " -> <: expr < Ast . StAnt $ mloc _loc $ $ e $ >> | " antictyp " -> <: expr < Ast . TyAnt $ mloc _loc $ $ e $ >> | " antipatt " -> <: expr < Ast . PaAnt $ mloc _loc $ $ e $ >> | " antiexpr " -> <: expr < Ast . ExAnt $ mloc _loc $ $ e $ >> | " antimodule_type " -> <: expr < Ast . MtAnt $ mloc _loc $ $ e $ >> | " antimodule_expr " -> <: expr < Ast . MeAnt $ mloc _loc $ $ e $ >> | " anticlass_type " -> <: expr < Ast . CtAnt $ mloc _loc $ $ e $ >> | " anticlass_expr " -> <: expr < Ast . CeAnt $ mloc _loc $ $ e $ >> | " anticlass_sig_item " -> <: expr < Ast . CgAnt $ mloc _loc $ $ e $ >> | " anticlass_str_item " -> <: expr < Ast . CrAnt $ mloc _loc $ $ e $ >> | " antiwith_constr " -> <: expr < Ast . WcAnt $ mloc _loc $ $ e $ >> | " antibinding " -> <: expr < Ast . BiAnt $ mloc _loc $ $ e $ >> | " antirec_binding " -> <: expr < Ast . RbAnt $ mloc _loc $ $ e $ >> | " antimatch_case " -> <: expr < Ast . McAnt $ mloc _loc $ $ e $ >> | " antimodule_binding " -> <: expr < Ast . MbAnt $ mloc _loc $ $ e $ >> | " antiident " -> <: expr < Ast . IdAnt $ mloc _loc $ $ e $ >> | _ -> e ] ) | e -> super # expr e ] ; end ; value add_quotation name entry mexpr mpatt = let entry_eoi = Gram . Entry . mk ( Gram . Entry . name entry ) in let parse_quot_string entry loc s = let q = Camlp4_config . antiquotations . val in let ( ) = Camlp4_config . antiquotations . val := True in let res = Gram . parse_string entry loc s in let ( ) = Camlp4_config . antiquotations . val := q in res in let expand_expr loc loc_name_opt s = let ast = parse_quot_string entry_eoi loc s in let ( ) = MetaLoc . loc_name . val := loc_name_opt in let meta_ast = mexpr loc ast in let exp_ast = antiquot_expander # expr meta_ast in exp_ast in let expand_str_item loc loc_name_opt s = let exp_ast = expand_expr loc loc_name_opt s in <: str_item @ loc < $ exp : exp_ast $ >> in let expand_patt _loc loc_name_opt s = let ast = parse_quot_string entry_eoi _loc s in let meta_ast = mpatt _loc ast in let exp_ast = antiquot_expander # patt meta_ast in match loc_name_opt with [ None -> exp_ast | Some name -> let rec subst_first_loc = fun [ <: patt @ _loc < Ast . $ uid : u $ $ _ $ >> -> <: patt < Ast . $ uid : u $ $ lid : name $ >> | <: patt @ _loc < $ a $ $ b $ >> -> <: patt < $ subst_first_loc a $ $ b $ >> | p -> p ] in subst_first_loc exp_ast ] in do { EXTEND Gram entry_eoi : [ [ x = entry ; ` EOI -> x ] ] ; END ; Quotation . add name Quotation . DynAst . expr_tag expand_expr ; Quotation . add name Quotation . DynAst . patt_tag expand_patt ; Quotation . add name Quotation . DynAst . str_item_tag expand_str_item ; } ; add_quotation " sig_item " sig_item_quot ME . meta_sig_item MP . meta_sig_item ; add_quotation " str_item " str_item_quot ME . meta_str_item MP . meta_str_item ; add_quotation " ctyp " ctyp_quot ME . meta_ctyp MP . meta_ctyp ; add_quotation " patt " patt_quot ME . meta_patt MP . meta_patt ; add_quotation " expr " expr_quot ME . meta_expr MP . meta_expr ; add_quotation " module_type " module_type_quot ME . meta_module_type MP . meta_module_type ; add_quotation " module_expr " module_expr_quot ME . meta_module_expr MP . meta_module_expr ; add_quotation " class_type " class_type_quot ME . meta_class_type MP . meta_class_type ; add_quotation " class_expr " class_expr_quot ME . meta_class_expr MP . meta_class_expr ; add_quotation " class_sig_item " class_sig_item_quot ME . meta_class_sig_item MP . meta_class_sig_item ; add_quotation " class_str_item " class_str_item_quot ME . meta_class_str_item MP . meta_class_str_item ; add_quotation " with_constr " with_constr_quot ME . meta_with_constr MP . meta_with_constr ; add_quotation " binding " binding_quot ME . meta_binding MP . meta_binding ; add_quotation " rec_binding " rec_binding_quot ME . meta_rec_binding MP . meta_rec_binding ; add_quotation " match_case " match_case_quot ME . meta_match_case MP . meta_match_case ; add_quotation " module_binding " module_binding_quot ME . meta_module_binding MP . meta_module_binding ; add_quotation " ident " ident_quot ME . meta_ident MP . meta_ident ; add_quotation " rec_flag " rec_flag_quot ME . meta_rec_flag MP . meta_rec_flag ; add_quotation " private_flag " private_flag_quot ME . meta_private_flag MP . meta_private_flag ; add_quotation " row_var_flag " row_var_flag_quot ME . meta_row_var_flag MP . meta_row_var_flag ; add_quotation " mutable_flag " mutable_flag_quot ME . meta_mutable_flag MP . meta_mutable_flag ; add_quotation " virtual_flag " virtual_flag_quot ME . meta_virtual_flag MP . meta_virtual_flag ; add_quotation " override_flag " override_flag_quot ME . meta_override_flag MP . meta_override_flag ; add_quotation " direction_flag " direction_flag_quot ME . meta_direction_flag MP . meta_direction_flag ; end ; |
module Widget = struct include Rawwidget type widget = raw_any raw_widget let default_toplevel = coe default_toplevel end |
module Protocol = struct open Widget include Protocol let opentk ( ) = coe ( opentk ( ) ) let opentk_with_args args = coe ( opentk_with_args args ) let openTk ? display ? clas ( ) = coe ( openTk ? display ? clas ( ) ) let cCAMLtoTKwidget table w = Widget . check_class w table ; TkToken ( Widget . name w ) let openTkClass s = coe ( openTkClass s ) let openTkDisplayClass disp c = coe ( openTkDisplayClass disp c ) end |
module Textvariable = struct open Textvariable type textVariable = Textvariable . textVariable let create = create let set = set let get = get let name = name let cCAMLtoTKtextVariable = cCAMLtoTKtextVariable let handle tv cbk = handle tv ~ callback : cbk let coerce = coerce let free = free let create_temporary w = create ~ on : w ( ) end |
module Fileevent = struct open Fileevent let add_fileinput fd callback = add_fileinput ~ fd ~ callback let remove_fileinput fd = remove_fileinput ~ fd let add_fileoutput fd callback = add_fileoutput ~ fd ~ callback let remove_fileoutput fd = remove_fileoutput ~ fd end |
module Timer = struct open Timer type t = Timer . t let add ms callback = add ~ ms ~ callback let set ms callback = set ~ ms ~ callback let remove = remove end |
let bind widget tag eventsequence action = tkCommand [ | cCAMLtoTKwidget widget_canvas_table widget ; TkToken " bind " ; cCAMLtoTKtagOrId tag ; cCAMLtoTKeventSequence eventsequence ; begin match action with | BindRemove -> TkToken " " | BindSet ( what , f ) -> let cbId = register_callback widget ( wrapeventInfo f what ) in TkToken ( " camlcb " ^ cbId ^ ( writeeventField what ) ) | BindSetBreakable ( what , f ) -> let cbId = register_callback widget ( wrapeventInfo f what ) in TkToken ( " camlcb " ^ cbId ^ ( writeeventField what ) ^ " ; if { $ BreakBindingsSequence == 1 } then { break ; } ; \ set BreakBindingsSequence 0 " ) | BindExtend ( what , f ) -> let cbId = register_callback widget ( wrapeventInfo f what ) in TkToken ( " + camlcb " ^ cbId ^ ( writeeventField what ) ) end ] | ; ; ## else |
let bind ~ events ( ? extend = false ) ( ? breakable = false ) ( ? fields = [ ] ) ? action widget tag = tkCommand [ | cCAMLtoTKwidget widget ; TkToken " bind " ; cCAMLtoTKtagOrId tag ; cCAMLtoTKeventSequence events ; begin match action with None -> TkToken " " | Some f -> let cbId = register_callback widget ~ callback : ( wrapeventInfo f fields ) in let cb = if extend then " + camlcb " else " camlcb " in let cb = cb ^ cbId ^ writeeventField fields in let cb = if breakable then cb ^ " ; if { $ BreakBindingsSequence == 1 } then { break ; } " ^ " ; set BreakBindingsSequence 0 " else cb in TkToken cb end ] | ; ; ## endif |
let packages = [ ( " 0install - solver " , " 2 . 17 " ) ; ( " afl - persistent " , " 1 . 3 " ) ; ( " alcotest " , " 1 . 4 . 0 " ) ; ( " astring " , " 0 . 8 . 5 " ) ; ( " base " , " v0 . 14 . 0 " ) ; ( " bechamel " , " 0 . 1 . 0 " ) ; ( " bos " , " 0 . 2 . 0 " ) ; ( " cmdliner " , " 1 . 0 . 4 " ) ; ( " cohttp " , " 4 . 0 . 0 " ) ; ( " core " , " v0 . 14 . 1 " ) ; ( " ctypes " , " 0 . 17 . 1 " ) ; ( " dune " , " 2 . 8 . 4 " ) ; ( " either " , " 1 . 0 . 0 " ) ; ( " fmt " , " 0 . 8 . 9 " ) ; ( " fpath " , " 0 . 7 . 2 " ) ; ( " logs " , " 0 . 7 . 0 " ) ; ( " lru " , " 0 . 3 . 0 " ) ; ( " lwt " , " 5 . 4 . 0 " ) ; ( " memtrace " , " 0 . 1 . 2 " ) ; ( " mirage " , " 3 . 10 . 1 " ) ; ( " mirage - clock " , " 3 . 1 . 0 " ) ; ( " mirage - clock - unix " , " 3 . 1 . 0 " ) ; ( " mirage - crypto " , " 0 . 10 . 1 " ) ; ( " optint " , " 0 . 1 . 0 " ) ; ( " ppx_repr " , " 0 . 3 . 0 " ) ; ( " repr " , " 0 . 3 . 0 " ) ; ( " stdio " , " v0 . 14 . 0 " ) ; ( " uucp " , " 13 . 0 . 0 " ) ; ( " uutf " , " 1 . 0 . 2 " ) ; ( " yojson " , " 1 . 7 . 0 " ) ; ( " zarith " , " 1 . 9 . 1 " ) ] |> Vector . of_list ~ dummy ( " " , : " " ) |
let setup_logs ( ) = let reporter = Progress . logs_reporter ( ) in Fmt_tty . setup_std_outputs ( ) ; Logs_threaded . enable ( ) ; Logs . set_reporter reporter |
let bar = let open Progress . Line in let total = Vector . length packages in list [ constf " % a " Fmt . ( styled ` Cyan string ) " Building " ; using fst ( brackets ( bar ~ style ( ` : Custom ( Bar_style . v [ " " ; = " " ; > " " ] ) ) ~ width ( ` : Fixed 40 ) total ) ) ; ticker_to total ; using snd string ] |
let rec package_worker ( active_packages , reporter ) = match Vector . pop packages with | exception Vector . Empty -> ( ) | package , version -> active_packages := package :: ! active_packages ; Logs . app ( fun f -> f " % a % s % s " Fmt . ( styled ` Green string ) " Compiling " package version ) ; Unix . sleepf ( Random . float 1 . ) ; active_packages := List . filter ( ( <> ) package ) ! active_packages ; reporter ( ) ; package_worker ( active_packages , reporter ) |
let run ( ) = setup_logs ( ) ; Random . self_init ( ) ; let cpus = 4 in let run_duration = Mtime_clock . counter ( ) in let active_packages = ref [ ] in Progress . with_reporter ~ config ( : Progress . Config . v ~ persistent : false ( ) ) bar ( fun reporter -> let reporter ( ) = let package_list = ! active_packages |> List . sort String . compare |> String . concat " , " in reporter ( 1 , package_list ) in let threads = List . init cpus ( fun _ -> Thread . create package_worker ( active_packages , reporter ) ) in List . iter Thread . join threads ) ; Logs . app ( fun f -> f " % a in % a " Fmt . ( styled ` Green string ) " Finished " Mtime . Span . pp ( Mtime_clock . count run_duration ) ) |
let command cmdline = if ! Clflags . verbose then begin prerr_string " + " ; prerr_string cmdline ; prerr_newline ( ) end ; Sys . command cmdline |
let run_command cmdline = ignore ( command cmdline ) |
let build_diversion lst = let ( responsefile , oc ) = Filename . open_temp_file " camlresp " " " in List . iter ( fun f -> Printf . fprintf oc " % s \ n " f ) lst ; close_out oc ; at_exit ( fun ( ) -> Misc . remove_file responsefile ) ; " " @ ^ responsefile |
let quote_files lst = let lst = List . filter ( fun f -> f <> " " ) lst in let quoted = List . map Filename . quote lst in let s = String . concat " " quoted in if String . length s >= 4096 && Sys . os_type = " Win32 " then build_diversion quoted else s |
let quote_prefixed pr lst = let lst = List . filter ( fun f -> f <> " " ) lst in let lst = List . map ( fun f -> pr ^ f ) lst in quote_files lst |
let quote_optfile = function | None -> " " | Some f -> Filename . quote f |
let compile_file name = command ( Printf . sprintf " % s - c % s % s % s % s " ( match ! Clflags . c_compiler with | Some cc -> cc | None -> if ! Clflags . native_code then Config . native_c_compiler else Config . bytecomp_c_compiler ) ( String . concat " " ( List . rev ! Clflags . ccopts ) ) ( quote_prefixed " - I " ( List . rev ! Clflags . include_dirs ) ) ( Clflags . std_include_flag " - I " ) ( Filename . quote name ) ) |
let create_archive archive file_list = Misc . remove_file archive ; let quoted_archive = Filename . quote archive in match Config . ccomp_type with " msvc " -> command ( Printf . sprintf " link / lib / nologo / out :% s % s " quoted_archive ( quote_files file_list ) ) | _ -> let r1 = command ( Printf . sprintf " ar rc % s % s " quoted_archive ( quote_files file_list ) ) in if r1 <> 0 || String . length Config . ranlib = 0 then r1 else command ( Config . ranlib ^ " " ^ quoted_archive ) |
let expand_libname name = if String . length name < 2 || String . sub name 0 2 <> " - l " then name else begin let libname = " lib " ^ String . sub name 2 ( String . length name - 2 ) ^ Config . ext_lib in try Misc . find_in_path ! Config . load_path libname with Not_found -> libname end |
type link_mode = | Exe | Dll | MainDll | Partial |
let call_linker mode output_name files extra = let files = quote_files files in let asmrun = " ' " ^ Config . standard_library ^ " / libasmrun . a ' " in let cmd = if mode = Partial then Printf . sprintf " % s % s % s % s " Config . native_pack_linker ( Filename . quote output_name ) files extra else Printf . sprintf " % s - o % s % s % s % s % s % s % s % s " ( match ! Clflags . c_compiler , mode with | Some cc , _ -> cc | None , Exe -> Config . mkexe | None , Dll -> Config . mkdll | None , MainDll -> Config . mkmaindll | None , Partial -> assert false ) ( Filename . quote output_name ) ( if ! Clflags . gprofile then Config . cc_profile else " " ) " " ( quote_prefixed " - L " ! Config . load_path ) ( String . concat " " ( List . rev ! Clflags . ccopts ) ) files asmrun extra in command cmd = 0 |
type os = Linux | OSX | Windows | Other |
let os = match Sys . os_type with | " Win32 " | " Cygwin " -> Windows | " Unix " -> ( try let in_channel = Unix . open_process_in " uname - s " in let os = try match input_line in_channel with | " Linux " -> Linux | " Darwin " -> OSX | _ -> Other with End_of_file -> Other in ignore ( Unix . close_process_in in_channel ) ; os with Unix . Unix_error _ -> Other ) | _ -> Other |
let is_unix = match os with | Linux | OSX | Other -> true | Windows -> false |
let ( / ) = Filename . concat |
let program_dir = let dir = Filename . dirname Sys . executable_name in if Filename . is_relative dir then Sys . getcwd ( ) / dir else dir |
let datadir = let default = if is_unix && Filename . basename program_dir = " bin " then Filename . dirname program_dir / " share " / " ocaml - top " else program_dir / " data " in let default = if Sys . file_exists default && Sys . is_directory default then default else Sys . getcwd ( ) / " data " in ref default |
let font = ref ( match os with | Linux | Other -> " DejaVu Sans Mono 10 " | OSX -> " Monaco 12 " | Windows -> " Lucida Console 10 " ) |
let char_width = ref 8 |
let theme = ref " dark " |
let ocaml_cmd , ocaml_opts , stdlib_dir = if Sys . os_type <> " Win32 " then ref " ocaml " , ref [ ] , None else if Sys . command " ocamlrun ocaml - vnum " = 0 then ref " ocamlrun " , ref [ " ocaml " ] , None else ref ( program_dir / " bin " / " ocamlrun " ) , ref [ program_dir / " bin " / " ocaml " ; " - I " ; program_dir / " lib " / " ocaml " ] , Some ( program_dir / " lib " / " ocaml " ) |
module State : sig type t val make : fun_name : string -> tailrec_label : Label . t -> contains_calls : bool -> Cfg . basic_block Label . Tbl . t -> t val get_fun_name : t -> string val get_tailrec_label : t -> Label . t val get_contains_calls : t -> bool val add_block : t -> label : Label . t -> block : Cfg . basic_block -> unit val get_layout : t -> Label . t list val add_catch_handler : t -> handler_id : int -> Label . t val get_catch_handler : t -> handler_id : int -> Label . t val get_next_instruction_id : t -> int val add_iend_with_poptrap : t -> Mach . instruction -> unit val is_iend_with_poptrap : t -> Mach . instruction -> bool val add_exception_handler : t -> Label . t -> unit val get_exception_handlers : t -> Label . t list type t = { fun_name : string ; tailrec_label : Label . t ; contains_calls : bool ; blocks : Cfg . basic_block Label . Tbl . t ; mutable layout : Label . t list ; catch_handlers : Label . t Numbers . Int . Tbl . t ; mutable next_instruction_id : int ; mutable iends_with_poptrap : Mach . instruction list ; mutable exception_handlers : Label . t list } let make ~ fun_name ~ tailrec_label ~ contains_calls blocks = let layout = [ ] in let catch_handlers = Numbers . Int . Tbl . create 31 in let next_instruction_id = 0 in let iends_with_poptrap = [ ] in let exception_handlers = [ ] in { fun_name ; tailrec_label ; contains_calls ; blocks ; layout ; catch_handlers ; next_instruction_id ; iends_with_poptrap ; exception_handlers } let get_fun_name t = t . fun_name let get_tailrec_label t = t . tailrec_label let get_contains_calls t = t . contains_calls let add_block t ~ label ~ block = if Label . Tbl . mem t . blocks label then Misc . fatal_errorf " Cfgize . State . add_block : duplicate block for label % d " label else begin t . layout <- label :: t . layout ; Label . Tbl . replace t . blocks label block end let get_layout t = List . rev t . layout let add_catch_handler t ~ handler_id = if Numbers . Int . Tbl . mem t . catch_handlers handler_id then Misc . fatal_errorf " Cfgize . State . add_catch_handler : duplicate handler % d " handler_id else let label = Cmm . new_label ( ) in Numbers . Int . Tbl . replace t . catch_handlers handler_id label ; label let get_catch_handler t ~ handler_id = match Numbers . Int . Tbl . find_opt t . catch_handlers handler_id with | Some res -> res | None -> Misc . fatal_errorf " Cfgize . State . get_handler_label : unknown handler_id % d " handler_id let get_next_instruction_id t = let res = t . next_instruction_id in t . next_instruction_id <- succ res ; res let is_iend instr = match instr . Mach . desc with | Iend -> true | Iop _ | Ireturn _ | Iifthenelse _ | Iswitch _ | Icatch _ | Iexit _ | Itrywith _ | Iraise _ -> false let add_iend_with_poptrap t iend = assert ( is_iend iend ) ; t . iends_with_poptrap <- iend :: t . iends_with_poptrap let is_iend_with_poptrap t iend = assert ( is_iend iend ) ; List . memq iend t . iends_with_poptrap let add_exception_handler t lbl = t . exception_handlers <- lbl :: t . exception_handlers let get_exception_handlers t = t . exception_handlers end |
type basic_or_terminator = | Basic of Cfg . basic | Terminator of Cfg . terminator |
let basic_or_terminator_of_operation : State . t -> Mach . operation -> basic_or_terminator = fun state op -> match op with | Imove -> Basic ( Op Move ) | Ispill -> Basic ( Op Spill ) | Ireload -> Basic ( Op Reload ) | Iconst_int i -> Basic ( Op ( Const_int i ) ) | Iconst_float f -> Basic ( Op ( Const_float f ) ) | Iconst_symbol s -> Basic ( Op ( Const_symbol s ) ) | Icall_ind -> Basic ( Call ( F Indirect ) ) | Icall_imm { func } -> Basic ( Call ( F ( Direct { func_symbol = func } ) ) ) | Itailcall_ind -> Terminator ( Tailcall ( Func Indirect ) ) | Itailcall_imm { func } -> Terminator ( Tailcall ( if String . equal ( State . get_fun_name state ) func then Self { destination = State . get_tailrec_label state } else Func ( Direct { func_symbol = func } ) ) ) | Iextcall { func ; ty_res ; ty_args ; alloc ; returns } -> let external_call = { Cfg . func_symbol = func ; alloc ; ty_res ; ty_args } in if returns then Basic ( Call ( P ( External external_call ) ) ) else Terminator ( Call_no_return external_call ) | Istackoffset ofs -> Basic ( Op ( Stackoffset ofs ) ) | Iload ( mem , mode , mut ) -> Basic ( Op ( Load ( mem , mode , mut ) ) ) | Istore ( mem , mode , assignment ) -> Basic ( Op ( Store ( mem , mode , assignment ) ) ) | Ialloc { bytes ; dbginfo ; mode } -> Basic ( Call ( P ( Alloc { bytes ; dbginfo ; mode } ) ) ) | Iintop Icheckbound -> Basic ( Call ( P ( Checkbound { immediate = None } ) ) ) | Iintop_imm ( Icheckbound , i ) -> Basic ( Call ( P ( Checkbound { immediate = Some i } ) ) ) | Iintop ( ( Iadd | Isub | Imul | Imulh _ | Idiv | Imod | Iand | Ior | Ixor | Ilsl | Ilsr | Iasr | Iclz _ | Ictz _ | Ipopcnt | Icomp _ ) as op ) -> Basic ( Op ( Intop op ) ) | Iintop_imm ( ( ( Iadd | Isub | Imul | Imulh _ | Idiv | Imod | Iand | Ior | Ixor | Ilsl | Ilsr | Iasr | Iclz _ | Ictz _ | Ipopcnt | Icomp _ ) as op ) , imm ) -> Basic ( Op ( Intop_imm ( op , imm ) ) ) | Icompf comp -> Basic ( Op ( Compf comp ) ) | Inegf -> Basic ( Op Negf ) | Iabsf -> Basic ( Op Absf ) | Iaddf -> Basic ( Op Addf ) | Isubf -> Basic ( Op Subf ) | Imulf -> Basic ( Op Mulf ) | Idivf -> Basic ( Op Divf ) | Ifloatofint -> Basic ( Op Floatofint ) | Iintoffloat -> Basic ( Op Intoffloat ) | Ispecific op -> Basic ( Op ( Specific op ) ) | Iopaque -> Basic ( Op Opaque ) | Iname_for_debugger _ -> Misc . fatal_error " Cfgize . basic_or_terminator_of_operation : " \ the Iname_for_debugger " \ \ instruction is currently not supported " | Iprobe { name ; handler_code_sym } -> Basic ( Op ( Probe { name ; handler_code_sym } ) ) | Iprobe_is_enabled { name } -> Basic ( Op ( Probe_is_enabled { name } ) ) | Ibeginregion -> Basic ( Op Begin_region ) | Iendregion -> Basic ( Op End_region ) |
let float_test_of_float_comparison : Cmm . float_comparison -> label_false : Label . t -> label_true : Label . t -> Cfg . float_test = fun comparison ~ label_false ~ label_true -> let lt , eq , gt , uo = match comparison with | CFeq -> label_false , label_true , label_false , label_false | CFneq -> label_true , label_false , label_true , label_true | CFlt -> label_true , label_false , label_false , label_false | CFnlt -> label_false , label_true , label_true , label_true | CFgt -> label_false , label_false , label_true , label_false | CFngt -> label_true , label_true , label_false , label_true | CFle -> label_true , label_true , label_false , label_false | CFnle -> label_false , label_false , label_true , label_true | CFge -> label_false , label_true , label_true , label_false | CFnge -> label_true , label_false , label_false , label_true in { lt ; eq ; gt ; uo } |
let int_test_of_integer_comparison : Cmm . integer_comparison -> signed : bool -> immediate : int option -> label_false : Label . t -> label_true : Label . t -> Cfg . int_test = fun comparison ~ signed : is_signed ~ immediate : imm ~ label_false ~ label_true -> let lt , eq , gt = match comparison with | Ceq -> label_false , label_true , label_false | Cne -> label_true , label_false , label_true | Clt -> label_true , label_false , label_false | Cgt -> label_false , label_false , label_true | Cle -> label_true , label_true , label_false | Cge -> label_false , label_true , label_true in { lt ; eq ; gt ; is_signed ; imm } |
let terminator_of_test : Mach . test -> label_false : Label . t -> label_true : Label . t -> Cfg . terminator = fun test ~ label_false ~ label_true -> let int_test comparison immediate = let signed , comparison = match comparison with | Mach . Isigned comparison -> true , comparison | Mach . Iunsigned comparison -> false , comparison in int_test_of_integer_comparison comparison ~ signed ~ immediate ~ label_false ~ label_true in match test with | Itruetest -> Truth_test { ifso = label_true ; ifnot = label_false } | Ifalsetest -> Truth_test { ifso = label_false ; ifnot = label_true } | Iinttest comparison -> Int_test ( int_test comparison None ) | Iinttest_imm ( comparison , value ) -> Int_test ( int_test comparison ( Some value ) ) | Ifloattest comparison -> Float_test ( float_test_of_float_comparison comparison ~ label_false ~ label_true ) | Ioddtest -> Parity_test { ifso = label_false ; ifnot = label_true } | Ieventest -> Parity_test { ifso = label_true ; ifnot = label_false } |
let make_instruction : type a . State . t -> desc : a -> a Cfg . instruction = fun state ~ desc -> let arg = [ ] || in let res = [ ] || in let dbg = Debuginfo . none in let live = Reg . Set . empty in let stack_offset = invalid_stack_offset in let id = State . get_next_instruction_id state in let fdo = Fdo_info . none in { desc ; arg ; res ; dbg ; live ; stack_offset ; id ; fdo } |
let copy_instruction : type a . State . t -> Mach . instruction -> desc : a -> a Cfg . instruction = fun state instr ~ desc -> let { Mach . arg ; res ; dbg ; live ; desc = _ ; next = _ ; available_before = _ ; available_across = _ } = instr in let stack_offset = invalid_stack_offset in let id = State . get_next_instruction_id state in let fdo = Fdo_info . none in { desc ; arg ; res ; dbg ; live ; stack_offset ; id ; fdo } |
let copy_instruction_no_reg : type a . State . t -> Mach . instruction -> desc : a -> a Cfg . instruction = fun state instr ~ desc -> let { Mach . arg = _ ; res = _ ; dbg ; live ; desc = _ ; next = _ ; available_before = _ ; available_across = _ } = instr in let arg = [ ] || in let res = [ ] || in let stack_offset = invalid_stack_offset in let id = State . get_next_instruction_id state in let fdo = Fdo_info . none in { desc ; arg ; res ; dbg ; live ; stack_offset ; id ; fdo } |
let rec get_end : Mach . instruction -> Mach . instruction = fun instr -> match instr . Mach . desc with | Iend -> instr | Iop _ | Ireturn _ | Iifthenelse _ | Iswitch _ | Icatch _ | Iexit _ | Itrywith _ | Iraise _ -> get_end instr . Mach . next |
type block_info = { instrs : Cfg . basic Cfg . instruction list ; last : Mach . instruction ; terminator : Cfg . terminator Cfg . instruction option } |
let extract_block_info : State . t -> Mach . instruction -> block_info = fun state first -> let rec loop ( instr : Mach . instruction ) acc = let return terminator instrs = let instrs = List . rev instrs in { instrs ; last = instr ; terminator } in match instr . desc with | Iop op -> begin match basic_or_terminator_of_operation state op with | Basic desc -> let instr ' = copy_instruction state instr ~ desc in let acc = instr ' :: acc in if Cfg . can_raise_basic desc then return None acc else loop instr . next acc | Terminator terminator -> return ( Some ( copy_instruction state instr ~ desc : terminator ) ) acc end | Iend | Ireturn _ | Iifthenelse _ | Iswitch _ | Icatch _ | Iexit _ | Itrywith _ -> return None acc | Iraise _ -> return None acc in loop first [ ] |
let fallthrough_label : Label . t = - 1 |
let rec add_blocks : Mach . instruction -> State . t -> starts_with_pushtrap : Label . t option -> start : Label . t -> next : Label . t -> unit = fun instr state ~ starts_with_pushtrap ~ start ~ next -> let { instrs ; last ; terminator } = extract_block_info state instr in let terminate_block ~ trap_actions terminator = let body = instrs in let body = match starts_with_pushtrap with | None -> body | Some lbl_handler -> make_instruction state ~ desc ( : Cfg . Pushtrap { lbl_handler } ) :: body in let body = body @ List . map ( function | Cmm . Push handler_id -> let lbl_handler = State . get_catch_handler state ~ handler_id in make_instruction state ~ desc ( : Cfg . Pushtrap { lbl_handler } ) | Cmm . Pop -> make_instruction state ~ desc : Cfg . Poptrap ) trap_actions in let body = match terminator . Cfg . desc with | Cfg . Return -> if State . get_contains_calls state then body @ [ make_instruction state ~ desc : Cfg . Reloadretaddr ] else body | Cfg . Never | Cfg . Always _ | Cfg . Parity_test _ | Cfg . Truth_test _ | Cfg . Float_test _ | Cfg . Int_test _ | Cfg . Switch _ | Cfg . Raise _ | Cfg . Tailcall _ | Cfg . Call_no_return _ -> body in let can_raise = let terminator_is_goto = match ( terminator . Cfg . desc : Cfg . terminator ) with | Always _ -> true | Raise _ | Tailcall _ | Call_no_return _ | Never | Parity_test _ | Truth_test _ | Float_test _ | Int_test _ | Switch _ | Return -> false in let rec check = function | [ ] -> false | [ last ] -> let res = Cfg . can_raise_basic last . Cfg . desc in assert ( ( not res ) || terminator_is_goto ) ; res | hd :: tail -> assert ( not ( Cfg . can_raise_basic hd . Cfg . desc ) ) ; check tail in let body_can_raise = check body in Cfg . can_raise_terminator terminator . Cfg . desc || body_can_raise in State . add_block state ~ label : start ~ block : { start ; body ; terminator ; predecessors = Label . Set . empty ; stack_offset = invalid_stack_offset ; exn = None ; can_raise ; is_trap_handler = false ; dead = false } in let prepare_next_block ( ) = match last . next . desc with | Iend when not ( State . is_iend_with_poptrap state last . next ) -> next , fun ( ) -> ( ) | Iend | Iop _ | Ireturn _ | Iifthenelse _ | Iswitch _ | Icatch _ | Iexit _ | Itrywith _ | Iraise _ -> let start = Cmm . new_label ( ) in let add_next_block ( ) = add_blocks last . next state ~ starts_with_pushtrap : None ~ start ~ next in start , add_next_block in match terminator with | Some terminator -> terminate_block ~ trap_actions [ ] : terminator | None -> ( match last . desc with | Iop op -> if not ( Mach . operation_can_raise op ) then Misc . fatal_error " Cfgize . extract_block_info : unexpected Iop with no terminator " ; let next , add_next_block = prepare_next_block ( ) in terminate_block ~ trap_actions [ ] : ( copy_instruction_no_reg state last ~ desc ( : Cfg . Always next ) ) ; add_next_block ( ) | Iend -> if Label . equal next fallthrough_label then terminate_block ~ trap_actions [ ] : ( copy_instruction_no_reg state last ~ desc : Cfg . Never ) else terminate_block ~ trap_actions : ( if State . is_iend_with_poptrap state last then [ Cmm . Pop ] else [ ] ) ( copy_instruction_no_reg state last ~ desc ( : Cfg . Always next ) ) | Ireturn trap_actions -> terminate_block ~ trap_actions ( copy_instruction state last ~ desc : Cfg . Return ) | Iifthenelse ( test , ifso , ifnot ) -> let label_true = Cmm . new_label ( ) in let label_false = Cmm . new_label ( ) in terminate_block ~ trap_actions [ ] : ( copy_instruction state last ~ desc ( : terminator_of_test test ~ label_false ~ label_true ) ) ; let next , add_next_block = prepare_next_block ( ) in add_blocks ifso state ~ starts_with_pushtrap : None ~ start : label_true ~ next ; add_blocks ifnot state ~ starts_with_pushtrap : None ~ start : label_false ~ next ; add_next_block ( ) | Iswitch ( indexes , cases ) -> let case_labels = Array . map ( fun _ -> Cmm . new_label ( ) ) cases in terminate_block ~ trap_actions [ ] : ( copy_instruction state last ~ desc ( : Cfg . Switch ( Array . map ( fun idx -> case_labels . ( idx ) ) indexes ) ) ) ; let next , add_next_block = prepare_next_block ( ) in Array . iteri ( fun idx case -> add_blocks case state ~ starts_with_pushtrap : None ~ start : case_labels . ( idx ) ~ next ) cases ; add_next_block ( ) | Icatch ( _rec , _trap_stack , handlers , body ) -> let handlers = List . map ( fun ( handler_id , _trap_stack , handler ) -> let handler_label = State . add_catch_handler state ~ handler_id in handler_label , handler ) handlers in let body_label = Cmm . new_label ( ) in terminate_block ~ trap_actions [ ] : ( copy_instruction_no_reg state last ~ desc ( : Cfg . Always body_label ) ) ; let next , add_next_block = prepare_next_block ( ) in add_blocks body state ~ starts_with_pushtrap : None ~ start : body_label ~ next ; List . iter ( fun ( handler_label , handler ) -> add_blocks handler state ~ starts_with_pushtrap : None ~ start : handler_label ~ next ) handlers ; add_next_block ( ) | Iexit ( handler_id , trap_actions ) -> let handler_label = State . get_catch_handler state ~ handler_id in terminate_block ~ trap_actions ( copy_instruction_no_reg state last ~ desc ( : Cfg . Always handler_label ) ) | Itrywith ( body , kind , ( _trap_stack , handler ) ) -> let label_body = Cmm . new_label ( ) in let label_handler , starts_with_pushtrap = match kind with | Regular -> let label = Cmm . new_label ( ) in label , Some label | Delayed handler_id -> let label = State . add_catch_handler state ~ handler_id in label , None in terminate_block ~ trap_actions [ ] : ( copy_instruction_no_reg state last ~ desc ( : Cfg . Always label_body ) ) ; let next , add_next_block = prepare_next_block ( ) in State . add_iend_with_poptrap state ( get_end body ) ; State . add_exception_handler state label_handler ; add_blocks body state ~ starts_with_pushtrap ~ start : label_body ~ next ; add_blocks handler state ~ starts_with_pushtrap : None ~ start : label_handler ~ next ; add_next_block ( ) | Iraise raise_kind -> terminate_block ~ trap_actions [ ] : ( copy_instruction state last ~ desc ( : Cfg . Raise raise_kind ) ) ) |
let update_trap_handler_blocks : State . t -> Cfg . t -> unit = fun state cfg -> List . iter ( fun label -> match Label . Tbl . find_opt cfg . blocks label with | None -> Misc . fatal_errorf " Cfgize . update_trap_handler_blocks : inconsistent state ( no block \ labelled % d ) " label | Some block -> block . is_trap_handler <- true ) ( State . get_exception_handlers state ) |
module Stack_offset_and_exn = struct type handler_stack = Label . t list let compute_stack_offset ~ stack_offset ~ traps = stack_offset + ( Proc . trap_size_in_bytes * List . length traps ) let check_and_set_stack_offset : ' a Cfg . instruction -> stack_offset : int -> traps : handler_stack -> ' a Cfg . instruction = fun instr ~ stack_offset ~ traps -> assert ( instr . stack_offset = invalid_stack_offset ) ; Cfg . set_stack_offset instr ( compute_stack_offset ~ stack_offset ~ traps ) let process_terminator : stack_offset : int -> traps : handler_stack -> Cfg . terminator Cfg . instruction -> int * handler_stack * Cfg . terminator Cfg . instruction = fun ~ stack_offset ~ traps term -> assert ( term . stack_offset = invalid_stack_offset ) ; let term = check_and_set_stack_offset term ~ stack_offset ~ traps in match term . desc with | Tailcall ( Self _ ) when List . length traps <> 0 || stack_offset <> 0 -> Misc . fatal_error " Cfgize . Stack_offset_and_exn . process_terminator : unexpected handler on \ self tailcall " | Tailcall ( Self _ ) | Never | Return | Tailcall ( Func _ ) | Call_no_return _ | Raise _ | Always _ | Parity_test _ | Truth_test _ | Float_test _ | Int_test _ | Switch _ -> stack_offset , traps , term let rec process_basic : Cfg . t -> stack_offset : int -> traps : handler_stack -> Cfg . basic Cfg . instruction -> int * handler_stack * Cfg . basic Cfg . instruction = fun cfg ~ stack_offset ~ traps instr -> let instr = check_and_set_stack_offset instr ~ stack_offset ~ traps in match instr . desc with | Pushtrap { lbl_handler } -> update_block cfg lbl_handler ~ stack_offset ~ traps ; stack_offset , lbl_handler :: traps , instr | Poptrap -> begin match traps with | [ ] -> Misc . fatal_error " Cfgize . Stack_offset_and_exn . process_basic : trying to pop from an \ empty stack " | _ :: traps -> stack_offset , traps , instr end | Op ( Stackoffset n ) -> stack_offset + n , traps , instr | Op ( Move | Spill | Reload | Const_int _ | Const_float _ | Const_symbol _ | Load _ | Store _ | Intop _ | Intop_imm _ | Negf | Absf | Addf | Subf | Mulf | Divf | Compf _ | Floatofint | Intoffloat | Probe _ | Probe_is_enabled _ | Opaque | Begin_region | End_region | Specific _ | Name_for_debugger _ ) | Call _ | Reloadretaddr | Prologue -> stack_offset , traps , instr and update_block : Cfg . t -> Label . t -> stack_offset : int -> traps : handler_stack -> unit = fun cfg label ~ stack_offset ~ traps -> let block = Cfg . get_block_exn cfg label in let was_invalid = if block . stack_offset = invalid_stack_offset then true else begin assert ( block . stack_offset = compute_stack_offset ~ stack_offset ~ traps ) ; false end in if was_invalid then begin block . stack_offset <- compute_stack_offset ~ stack_offset ~ traps ; let stack_offset , traps , body = ListLabels . fold_left block . body ~ init ( : stack_offset , traps , [ ] ) ~ f ( : fun ( stack_offset , traps , body ) instr -> let stack_offset , traps , instr = process_basic cfg ~ stack_offset ~ traps instr in stack_offset , traps , instr :: body ) in block . body <- List . rev body ; let stack_offset , traps , terminator = process_terminator ~ stack_offset ~ traps block . terminator in block . terminator <- terminator ; Label . Set . iter ( update_block cfg ~ stack_offset ~ traps ) ( Cfg . successor_labels ~ normal : true ~ exn : false block ) ; if block . can_raise then begin assert ( Option . is_none block . exn ) ; match traps with | [ ] -> ( ) | handler_label :: _ -> block . exn <- Some handler_label end end let update_cfg : Cfg . t -> unit = fun cfg -> update_block cfg cfg . entry_label ~ stack_offset : 0 ~ traps [ ] ; : Cfg . iter_blocks cfg ~ f ( : fun _ block -> if block . stack_offset = invalid_stack_offset then block . dead <- true ) ; Cfg . iter_blocks cfg ~ f ( : fun _ block -> assert ( not ( block . is_trap_handler && block . dead ) ) ) end |
let fundecl : Mach . fundecl -> preserve_orig_labels : bool -> simplify_terminators : bool -> Cfg_with_layout . t = fun fundecl ~ preserve_orig_labels ~ simplify_terminators -> let { Mach . fun_name ; fun_args ; fun_body ; fun_codegen_options ; fun_dbg ; fun_num_stack_slots ; fun_contains_calls } = fundecl in let start_label = Cmm . new_label ( ) in let tailrec_label = Cmm . new_label ( ) in let fun_fast = not ( List . mem Cmm . Reduce_code_size fun_codegen_options ) in let prologue_required = Proc . prologue_required ~ fun_contains_calls ~ fun_num_stack_slots in let cfg = Cfg . create ~ fun_name ~ fun_args ~ fun_dbg ~ fun_fast ~ fun_contains_calls ~ fun_num_stack_slots in let state = State . make ~ fun_name ~ tailrec_label ~ contains_calls : fun_contains_calls cfg . blocks in State . add_block state ~ label ( : Cfg . entry_label cfg ) ~ block : { start = Cfg . entry_label cfg ; body = begin match prologue_required with | false -> [ ] | true -> let dbg = fun_body . dbg in let fdo = Fdo_info . none in [ { ( make_instruction state ~ desc : Cfg . Prologue ) with dbg ; fdo } ] end ; terminator = copy_instruction_no_reg state fun_body ~ desc ( : Cfg . Always tailrec_label ) ; predecessors = Label . Set . empty ; stack_offset = invalid_stack_offset ; exn = None ; can_raise = false ; is_trap_handler = false ; dead = false } ; State . add_block state ~ label : tailrec_label ~ block : { start = tailrec_label ; body = [ ] ; terminator = copy_instruction_no_reg state fun_body ~ desc ( : Cfg . Always start_label ) ; predecessors = Label . Set . empty ; stack_offset = invalid_stack_offset ; exn = None ; can_raise = false ; is_trap_handler = false ; dead = false } ; add_blocks fun_body state ~ starts_with_pushtrap : None ~ start : start_label ~ next : fallthrough_label ; update_trap_handler_blocks state cfg ; Stack_offset_and_exn . update_cfg cfg ; Cfg . register_predecessors_for_all_blocks cfg ; let cfg_with_layout = Cfg_with_layout . create cfg ~ layout ( : State . get_layout state ) ~ preserve_orig_labels ~ new_labels : Label . Set . empty in if simplify_terminators then Merge_straightline_blocks . run cfg_with_layout ; Eliminate_dead_code . run_dead_block cfg_with_layout ; if simplify_terminators then Simplify_terminator . run cfg ; cfg_with_layout |
module type Forward_domain = sig type t val top : t val bot : t val compare : t -> t -> int val join : t -> t -> t val to_string : t -> string end |
module type Forward_transfer = sig type domain type t = { normal : domain ; exceptional : domain } val basic : domain -> Cfg . basic Cfg . instruction -> t val terminator : domain -> Cfg . terminator Cfg . instruction -> t end |
module type Forward_S = sig type domain type map = domain Label . Tbl . t val run : Cfg . t -> ? max_iteration : int -> ? init : domain -> unit -> ( map , map ) Result . t end |
module Forward ( D : Forward_domain ) ( T : Forward_transfer with type domain = D . t ) : Forward_S with type domain = D . t = struct type domain = D . t type transfer = T . t type map = domain Label . Tbl . t module WorkSetElement = struct type t = { label : Label . t ; value : domain } let compare { label = left_label ; value = left_value } { label = right_label ; value = right_value } = match Label . compare left_label right_label with | 0 -> D . compare left_value right_value | res -> res end module WorkSet = Set . Make ( WorkSetElement ) let transfer_block : domain -> Cfg . basic_block -> transfer = fun value block -> let transfer f ( acc_normal , acc_exceptional ) instr = let { T . normal ; exceptional } = f acc_normal instr in normal , D . join exceptional acc_exceptional in let normal , exceptional = transfer T . terminator ( ListLabels . fold_left block . body ~ init ( : value , value ) ~ f ( : transfer T . basic ) ) block . terminator in { normal ; exceptional } let create : Cfg . t -> init : domain option -> map * WorkSet . t ref = fun cfg ~ init -> let map = Label . Tbl . create ( Label . Tbl . length cfg . Cfg . blocks ) in let set = ref WorkSet . empty in let value = Option . value init ~ default : D . top in Cfg . iter_blocks cfg ~ f ( : fun label block -> if Label . equal label cfg . entry_label || block . is_trap_handler then set := WorkSet . add { WorkSetElement . label ; value } ! set ) ; map , set let remove_and_return : Cfg . t -> WorkSet . t ref -> WorkSetElement . t * Cfg . basic_block = fun cfg set -> let element = WorkSet . choose ! set in set := WorkSet . remove element ! set ; element , Cfg . get_block_exn cfg element . label let run : Cfg . t -> ? max_iteration : int -> ? init : domain -> unit -> ( map , map ) Result . t = fun cfg ( ? max_iteration = max_int ) ? init ( ) -> let res , work_set = create cfg ~ init in let iteration = ref 0 in while ( not ( WorkSet . is_empty ! work_set ) ) && ! iteration < max_iteration do incr iteration ; let element , block = remove_and_return cfg work_set in let ( { normal ; exceptional } : T . t ) = transfer_block element . value block in let update ~ normal ~ exn value = Label . Set . iter ( fun successor_label -> let old_value = Option . value ( Label . Tbl . find_opt res successor_label ) ~ default : D . bot in let new_value = D . join old_value value in if not ( D . compare new_value old_value <= 0 ) then begin Label . Tbl . replace res successor_label new_value ; work_set := WorkSet . add { WorkSetElement . label = successor_label ; value = new_value } ! work_set end ) ( Cfg . successor_labels ~ normal ~ exn block ) in update ~ normal : true ~ exn : false normal ; update ~ normal : false ~ exn : true exceptional done ; if WorkSet . is_empty ! work_set then Result . Ok res else Result . Error res end |
module type Backward_domain = sig type t val bot : t val compare : t -> t -> int val join : t -> t -> t val less_equal : t -> t -> bool val to_string : t -> string end |
module type Backward_transfer = sig type domain val basic : domain -> exn : domain -> Cfg . basic Cfg . instruction -> domain val terminator : domain -> exn : domain -> Cfg . terminator Cfg . instruction -> domain val exception_ : domain -> domain end |
module type Backward_S = sig type domain type _ map = | Block : domain Label . Tbl . t map | Instr : domain Instr . Tbl . t map val run : Cfg . t -> ? max_iteration : int -> init : domain -> map ' : a map -> unit -> ( ' a , ' a ) Result . t end |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.