From 720648c36a01991e1b5248ca9de5b17cdd3ba693 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Vouillon?= Date: Thu, 17 Apr 2025 11:08:16 +0200 Subject: [PATCH 1/7] Fix Subst.Including_Binders.And_Continuations Rewrite code locations everywhere, so that it can used to duplicate nested functions. --- compiler/lib/subst.ml | 29 ++++++++++++++++++++++++++++- 1 file changed, 28 insertions(+), 1 deletion(-) diff --git a/compiler/lib/subst.ml b/compiler/lib/subst.ml index 4e0bc66e99..cfa7cd1593 100644 --- a/compiler/lib/subst.ml +++ b/compiler/lib/subst.ml @@ -159,6 +159,33 @@ module Including_Binders = struct module And_Continuations = struct let subst_cont m s (pc, arg) = Addr.Map.find pc m, List.map arg ~f:s + let expr m s e = + match e with + | Constant _ -> e + | Apply { f; args; exact } -> Apply { f = s f; args = List.map args ~f:s; exact } + | Block (n, a, k, mut) -> Block (n, Array.map a ~f:s, k, mut) + | Field (x, n, typ) -> Field (s x, n, typ) + | Closure (l, pc, loc) -> Closure (List.map l ~f:s, subst_cont m s pc, loc) + | Special _ -> e + | Prim (p, l) -> + Prim + ( p + , List.map l ~f:(fun x -> + match x with + | Pv x -> Pv (s x) + | Pc _ -> x) ) + + let instr m s i = + match i with + | Let (x, e) -> Let (s x, expr m s e) + | Assign (x, y) -> Assign (s x, s y) + | Set_field (x, n, typ, y) -> Set_field (s x, n, typ, s y) + | Offset_ref (x, n) -> Offset_ref (s x, n) + | Array_set (x, y, z) -> Array_set (s x, s y, s z) + | Event _ -> i + + let instrs m s l = List.map l ~f:(fun i -> instr m s i) + let last m s l = match l with | Stop -> l @@ -173,7 +200,7 @@ module Including_Binders = struct let block m s block = { params = List.map ~f:s block.params - ; body = instrs s block.body + ; body = instrs m s block.body ; branch = last m s block.branch } end From fa80456165e885f5e1aa9bc980d5b8fdab4d2271 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Vouillon?= Date: Thu, 17 Apr 2025 11:21:19 +0200 Subject: [PATCH 2/7] Duplicate.closure now handles the computation of the bound variables --- compiler/lib/duplicate.ml | 68 +++++++++++++++++++++++++++++--------- compiler/lib/duplicate.mli | 11 +++--- compiler/lib/inline.ml | 5 ++- 3 files changed, 58 insertions(+), 26 deletions(-) diff --git a/compiler/lib/duplicate.ml b/compiler/lib/duplicate.ml index 683bba7d4b..e54684aa06 100644 --- a/compiler/lib/duplicate.ml +++ b/compiler/lib/duplicate.ml @@ -19,29 +19,65 @@ open! Stdlib open Code -let closure p ~bound_vars ~f ~params ~cont:(pc, args) = - let s = - Subst.from_map - (Var.Set.fold (fun x s -> Var.Map.add x (Var.fork x) s) bound_vars Var.Map.empty) - in - let free_pc, m = +let bound_variables { blocks; _ } ~f ~params ~cont:(pc, _) = + let bound_vars = ref Var.Map.empty in + let add_var x = bound_vars := Var.Map.add x (Var.fork x) !bound_vars in + List.iter ~f:add_var (f :: params); + let rec traverse blocks pc = Code.traverse - { fold = Code.fold_children } - (fun pc (pc', m) -> pc' + 1, Addr.Map.add pc pc' m) + { fold = fold_children } + (fun pc _ -> + let block = Addr.Map.find pc blocks in + Freevars.iter_block_bound_vars add_var block; + List.iter + ~f:(fun i -> + match i with + | Let (_, Closure (params, (pc', _), _)) -> + List.iter ~f:add_var params; + traverse blocks pc' + | _ -> ()) + block.body) pc - p.blocks - (p.free_pc, Addr.Map.empty) + blocks + () + in + traverse blocks pc; + !bound_vars + +let rec blocks_to_rename p pc lst = + Code.traverse + { fold = Code.fold_children } + (fun pc lst -> + let block = Addr.Map.find pc p.blocks in + List.fold_left + ~f:(fun lst i -> + match i with + | Let (_, Closure (_, (pc', _), _)) -> blocks_to_rename p pc' lst + | _ -> lst) + ~init:(pc :: lst) + block.body) + pc + p.blocks + lst + +let closure p ~f ~params ~cont = + let s = Subst.from_map (bound_variables p ~f ~params ~cont) in + let pc, args = cont in + let blocks = blocks_to_rename p pc [] in + let free_pc, m = + List.fold_left + ~f:(fun (pc', m) pc -> pc' + 1, Addr.Map.add pc pc' m) + ~init:(p.free_pc, Addr.Map.empty) + blocks in let blocks = - Code.traverse - { fold = Code.fold_children } - (fun pc blocks -> + List.fold_left + ~f:(fun blocks pc -> let b = Addr.Map.find pc blocks in let b = Subst.Including_Binders.And_Continuations.block m s b in Addr.Map.add (Addr.Map.find pc m) b blocks) - pc - p.blocks - p.blocks + ~init:p.blocks + blocks in let p = { p with blocks; free_pc } in p, s f, List.map ~f:s params, (Addr.Map.find pc m, List.map ~f:s args) diff --git a/compiler/lib/duplicate.mli b/compiler/lib/duplicate.mli index 3ebbea1866..25fb854bd2 100644 --- a/compiler/lib/duplicate.mli +++ b/compiler/lib/duplicate.mli @@ -18,14 +18,11 @@ val closure : Code.program - -> bound_vars:Code.Var.Set.t -> f:Code.Var.t -> params:Code.Var.t list -> cont:int * Code.Var.t list -> Code.program * Code.Var.t * Code.Var.t list * (int * Code.Var.t list) -(** Given a program and a closure [f] -- defined by its name, parameters, and its - continuation --, return a program in which the body of [f] has been updated with fresh - variable names to replace elements of [bound_vars]. Also returns the new name of [f] - (fresh if [f] is in [bound_vars]), and the similarly substituted parameter list and - continuation. - *) +(** Given a program and a closure [f] -- defined by its name, + parameters, and its continuation --, return a program with a copy + of [f]. Also returns the new name of [f], and the similarly + substituted parameter list and continuation. *) diff --git a/compiler/lib/inline.ml b/compiler/lib/inline.ml index b4f5cdcd44..102e1168c3 100644 --- a/compiler/lib/inline.ml +++ b/compiler/lib/inline.ml @@ -230,7 +230,7 @@ let inline inline_count live_vars closures pc (outer, p) = [], (outer, Branch (fresh_addr, args), { p with blocks; free_pc })) else match cl_simpl with - | Some (bound_vars, free_vars, recursive, tc_params) + | Some (_, free_vars, recursive, tc_params) (* We inline/duplicate - single instruction functions (f_size = 1) - small funtions that call one of their arguments in @@ -255,8 +255,7 @@ let inline inline_count live_vars closures pc (outer, p) = live_vars.(Var.idx f) <- live_vars.(Var.idx f) - 1 in let p, f, params, clos_cont = - let bound_vars = Var.Set.add f bound_vars in - Duplicate.closure p ~bound_vars ~f ~params ~cont:clos_cont + Duplicate.closure p ~f ~params ~cont:clos_cont in if recursive then From bf59aaacf876b8ffaf7b66f28bf6354ec11e60c3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Vouillon?= Date: Thu, 17 Apr 2025 11:26:30 +0200 Subject: [PATCH 3/7] Move Effect.last_intr to Code.last_instr --- compiler/lib/code.ml | 6 ++++++ compiler/lib/code.mli | 3 +++ compiler/lib/effects.ml | 9 +-------- 3 files changed, 10 insertions(+), 8 deletions(-) diff --git a/compiler/lib/code.ml b/compiler/lib/code.ml index b99fc400f3..5a7c294021 100644 --- a/compiler/lib/code.ml +++ b/compiler/lib/code.ml @@ -791,6 +791,12 @@ let fold_closures_outermost_first { start; blocks; _ } f accu = let accu = f None [] (start, []) None accu in visit blocks start f accu +let rec last_instr l = + match l with + | [] | [ Event _ ] -> None + | [ i ] | [ i; Event _ ] -> Some i + | _ :: rem -> last_instr rem + let eq p1 p2 = p1.start = p2.start && Addr.Map.equal diff --git a/compiler/lib/code.mli b/compiler/lib/code.mli index 37a0f00cc3..5bcad76b3d 100644 --- a/compiler/lib/code.mli +++ b/compiler/lib/code.mli @@ -311,6 +311,9 @@ val traverse : val preorder_traverse : fold_blocs_poly -> (Addr.t -> 'c -> 'c) -> Addr.t -> block Addr.Map.t -> 'c -> 'c +val last_instr : instr list -> instr option +(** Last instruction of a block body, ignoring events *) + val prepend : program -> instr list -> program val empty : program diff --git a/compiler/lib/effects.ml b/compiler/lib/effects.ml index 8cb952fa4c..c69f11fdac 100644 --- a/compiler/lib/effects.ml +++ b/compiler/lib/effects.ml @@ -142,13 +142,6 @@ let dominance_frontier g idom = g.preds; frontiers -(* Last instruction of a block, ignoring events *) -let rec last_instr l = - match l with - | [] -> None - | [ i ] | [ i; Event _ ] -> Some i - | _ :: rem -> last_instr rem - (* Split a block, separating the last instruction from the preceeding ones, ignoring events *) let block_split_last xs = @@ -210,7 +203,7 @@ let compute_needed_transformations ~cfg ~idom ~cps_needed ~blocks ~start = let block = Addr.Map.find pc blocks in (match block.branch with | Branch (dst, _) -> ( - match last_instr block.body with + match Code.last_instr block.body with | Some (Let (x, e)) when effect_primitive_or_application e && Var.Set.mem x cps_needed -> (* The block after a function application that needs to From 4c740256b08fbc6a76e3a750cbb15c7d3065b115 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Vouillon?= Date: Thu, 10 Apr 2025 17:52:07 +0200 Subject: [PATCH 4/7] Rewrite inline pass - We are a lot more aggressive at inlining functor-like functions, since this may enable further optimizations. - We are more cautious at inlining nested functions, since this can result in memory leaks. - We inline a larger class of small functions --- compiler/lib/config.ml | 2 +- compiler/lib/driver.ml | 22 +- compiler/lib/inline.ml | 825 ++++++++++++++------- compiler/lib/inline.mli | 2 +- compiler/tests-compiler/global_deadcode.ml | 1 + 5 files changed, 573 insertions(+), 279 deletions(-) diff --git a/compiler/lib/config.ml b/compiler/lib/config.ml index 15488319a4..f9f10493c2 100644 --- a/compiler/lib/config.ml +++ b/compiler/lib/config.ml @@ -135,7 +135,7 @@ module Param = struct p ~name:"switch_size" ~desc:"set the maximum number of case in a switch" (int 60) let inlining_limit = - p ~name:"inlining-limit" ~desc:"set the size limit for inlining" (int 200) + p ~name:"inlining-limit" ~desc:"set the size limit for inlining" (int 150) let tailcall_max_depth = p diff --git a/compiler/lib/driver.ml b/compiler/lib/driver.ml index 484489069e..3eda52981d 100644 --- a/compiler/lib/driver.ml +++ b/compiler/lib/driver.ml @@ -54,12 +54,12 @@ let deadcode p = let r, live_vars = deadcode' p in Deadcode.remove_empty_blocks ~live_vars r -let inline p = +let inline aggressive p = if Config.Flag.inline () && Config.Flag.deadcode () then ( let p, live_vars = deadcode' p in if debug () then Format.eprintf "Inlining...@."; - Inline.f p live_vars) + Inline.f ~aggressive p live_vars) else p let specialize_1 (p, info) = @@ -159,36 +159,38 @@ let rec loop max name round i (p : 'a) : 'a = (* o1 *) -let o1 : 'a -> 'a = +let round opt : 'a -> 'a = print +> tailcall +> flow +> specialize +> eval - +> inline (* inlining may reveal new tailcall opt *) + +> inline opt (* inlining may reveal new tailcall opt *) +> deadcode +> tailcall +> phi +> flow +> specialize +> eval - +> inline + +> inline opt +> deadcode +> print +> flow +> specialize +> eval - +> inline + +> inline opt +> deadcode +> phi +let o1 = round false + (* o2 *) -let o2 = loop 10 "o1" o1 1 +> print +let o2 = loop 10 "o1" (round true) 1 +> print (* o3 *) -let o3 = loop 10 "o1" o1 1 +> print +let o3 = loop 10 "o1" (round true) 1 +> print let generate ~exported_runtime @@ -438,7 +440,9 @@ let check_js js = Javascript.IdentSet.fold (fun x acc -> match x with - | V _ -> assert false + | V y -> + Format.eprintf "ZZZ %a@." Code.Var.print y; + assert false | S { name = Utf8 x; _ } -> StringSet.add x acc) free StringSet.empty diff --git a/compiler/lib/inline.ml b/compiler/lib/inline.ml index 102e1168c3..0644f0c538 100644 --- a/compiler/lib/inline.ml +++ b/compiler/lib/inline.ml @@ -21,129 +21,454 @@ open! Stdlib open Code -type prop = - { size : int - ; optimizable : bool +let debug = Debug.find "inlining" + +let times = Debug.find "times" + +let stats = Debug.find "stats" + +(****) + +(* +We try to find a good order to traverse the code: +- when a function calls another function or contains another function, + we process it after the other function +- in case of recursive cycles, we process functions called only once + first +*) + +let collect_closures p = + let closures = Var.Hashtbl.create 128 in + let rec traverse p enclosing pc = + Code.traverse + { fold = Code.fold_children } + (fun pc () -> + let block = Addr.Map.find pc p.blocks in + List.iter + ~f:(fun i -> + match i with + | Let (f, Closure (params, ((pc', _) as cont), _)) -> + Var.Hashtbl.add closures f (params, cont, enclosing); + traverse p (Some f) pc' + | _ -> ()) + block.body) + pc + p.blocks + () + in + traverse p None p.start; + closures + +let collect_deps p closures = + let deps = Var.Hashtbl.create (Var.Hashtbl.length closures) in + Var.Hashtbl.iter (fun f _ -> Var.Hashtbl.add deps f (ref Var.Set.empty)) closures; + let traverse p g pc = + let add_dep f = + if Var.Hashtbl.mem closures f + then + let s = Var.Hashtbl.find deps f in + s := Var.Set.add g !s + in + Code.traverse + { fold = Code.fold_children } + (fun pc () -> + let block = Addr.Map.find pc p.blocks in + Freevars.iter_block_free_vars add_dep block; + List.iter + ~f:(fun i -> + match i with + | Let (f, Closure _) -> add_dep f + | _ -> ()) + block.body) + pc + p.blocks + () + in + Var.Hashtbl.iter (fun f (_, (pc, _), _) -> traverse p f pc) closures; + Var.Hashtbl.fold (fun f s m -> Var.Map.add f !s m) deps Var.Map.empty + +module Var_SCC = Strongly_connected_components.Make (Var) + +let visit_closures p ~live_vars f acc = + let closures = collect_closures p in + let deps = collect_deps p closures in + let scc = Var_SCC.connected_components_sorted_from_roots_to_leaf deps in + let f' recursive acc g = + let params, cont, enclosing_function = Var.Hashtbl.find closures g in + f ~recursive ~enclosing_function ~current_function:(Some g) ~params ~cont acc + in + let acc = + Array.fold_left + scc + ~f:(fun acc group -> + match group with + | Var_SCC.No_loop g -> f' false acc g + | Has_loop l -> + let set = Var.Set.of_list l in + let deps' = + List.fold_left + ~f:(fun deps' g -> + Var.Map.add + g + (if live_vars.(Var.idx g) > 1 + then Var.Set.empty + else Var.Set.inter (Var.Map.find g deps) set) + deps') + ~init:Var.Map.empty + l + in + let scc = Var_SCC.connected_components_sorted_from_roots_to_leaf deps' in + Array.fold_left + scc + ~f:(fun acc group -> + match group with + | Var_SCC.No_loop g -> f' true acc g + | Has_loop l -> List.fold_left ~f:(fun acc g -> f' true acc g) ~init:acc l) + ~init:acc) + ~init:acc + in + f + ~recursive:false + ~enclosing_function:None + ~current_function:None + ~params:[] + ~cont:(p.start, []) + acc + +(****) + +module SCC = Strongly_connected_components.Make (Addr) + +let blocks_in_loop p pc = + let g = + Code.traverse + { fold = Code.fold_children } + (fun pc g -> + Addr.Map.add pc (Code.fold_children p.blocks pc Addr.Set.add Addr.Set.empty) g) + pc + p.blocks + Addr.Map.empty + in + let scc = SCC.component_graph g in + Array.fold_left + ~f:(fun s (c, _) -> + match c with + | SCC.No_loop _ -> s + | Has_loop l -> List.fold_left ~f:(fun s x -> Addr.Set.add x s) l ~init:s) + ~init:Addr.Set.empty + scc + +(****) + +type 'a cache = 'a option ref + +type info = + { f : Var.t + ; params : Var.t list + ; cont : Code.cont + ; enclosing_function : Var.t option + ; recursive : bool + ; loops : bool cache + ; body_size : int cache + ; full_size : int cache + ; closure_count : int cache + ; init_code : int cache + ; returns_a_block : bool cache + ; interesting_params : (Var.t * int) list cache } -type closure_info = - { cl_params : Var.t list - ; cl_cont : int * Var.t list - ; cl_prop : prop - ; cl_simpl : (Var.Set.t * int Var.Map.t * bool * Var.Set.t) option - ; cl_loc : Parse_info.t option +type context = + { aggressive : bool + ; p : program + ; live_vars : int array + ; inline_count : int ref + ; env : info Var.Map.t + ; in_loop : bool + ; has_closures : bool ref + ; current_function : Var.t option + ; enclosing_function : Var.t option } -let block_size { branch; body; _ } = +let cache ~info:{ cont = pc, _; _ } ref f = + match !ref with + | Some v -> v + | None -> + let v = f pc in + ref := Some v; + v + +let contains_loop ~context info = + cache ~info info.loops (fun pc -> + let rec traverse pc ((visited, loop) as accu) : _ * bool = + if loop + then accu + else if Addr.Map.mem pc visited + then visited, Addr.Map.find pc visited + else + let visited, loop = + Code.fold_children + context.p.blocks + pc + traverse + (Addr.Map.add pc true visited, false) + in + Addr.Map.add pc false visited, loop + in + snd (traverse pc (Addr.Map.empty, false))) + +let sum ~context f pc = + let blocks = context.p.blocks in + Code.traverse + { fold = fold_children } + (fun pc acc -> f (Addr.Map.find pc blocks) + acc) + pc + blocks + 0 + +let rec block_size ~recurse ~context { branch; body; _ } = List.fold_left ~f:(fun n i -> match i with | Event _ -> n + | Let (_, Closure (_, (pc, _), _)) -> + if recurse then size ~recurse ~context pc + n + 1 else n + 1 | _ -> n + 1) - ~init:0 + ~init: + (match branch with + | Cond _ | Raise _ -> 2 + | Switch (_, a1) -> Array.length a1 + | _ -> 0) body - + - match branch with - | Cond _ -> 2 - | Switch (_, a1) -> Array.length a1 - | _ -> 0 - -let simple_function blocks size name params pc = - let bound_vars = - ref (List.fold_left ~f:(fun s x -> Var.Set.add x s) ~init:Var.Set.empty params) - in - let free_vars = ref Var.Map.empty in - let tc = ref Var.Set.empty in + +and size ~recurse ~context = sum ~context (block_size ~recurse ~context) + +let body_size ~context info = cache ~info info.body_size (size ~recurse:false ~context) + +let full_size ~context info = cache ~info info.full_size (size ~recurse:true ~context) + +let closure_count_uncached ~context = + sum ~context (fun { body; _ } -> + List.fold_left + ~f:(fun n i -> + match i with + | Let (_, Closure _) -> n + 1 + | _ -> n) + ~init:0 + body) + +let closure_count ~context info = + cache ~info info.closure_count (closure_count_uncached ~context) + +let count_init_code ~context info = + cache + ~info + info.init_code + (sum ~context + @@ fun { body; _ } -> + List.fold_left + ~f:(fun n i -> + match i with + | Let (_, (Closure _ | Field _ | Constant _ | Block _)) -> n + 1 + | Let (_, (Apply _ | Prim _ | Special _)) + | Assign _ | Set_field _ | Offset_ref _ | Array_set _ | Event _ -> n) + ~init:0 + body) + +let returns_a_block ~context info = + cache ~info info.returns_a_block (fun pc -> + let blocks = context.p.blocks in + Code.traverse + { fold = fold_children } + (fun pc acc -> + acc + && + let block = Addr.Map.find pc blocks in + match block.branch with + | Return x -> ( + match Code.last_instr block.body with + | Some (Let (x', Block _)) -> Var.equal x x' + | _ -> false) + | Raise _ | Stop | Branch _ | Cond _ | Switch _ | Pushtrap _ | Poptrap _ -> true) + pc + blocks + true) + +let interesting_parameters ~context info = + let params = info.params in + cache ~info info.interesting_params (fun pc -> + let params = List.filter ~f:(fun x -> context.live_vars.(Var.idx x) = 1) params in + if List.is_empty params + then [] + else + let blocks = context.p.blocks in + Code.traverse + { fold = fold_children } + (fun pc lst -> + let block = Addr.Map.find pc blocks in + List.fold_left + ~f:(fun lst i -> + match i with + | Let (_, Apply { f; args; _ }) when List.mem f ~set:params -> + (f, List.length args) :: lst + | _ -> lst) + ~init:lst + block.body) + pc + blocks + []) + +(* + We are very aggressive at optimizing functor-like code, even if + this might duplicate quite a lot of code, since this is likely to + allow other optimizations: direct function calls, more precise dead + code elimination, ... +*) +let functor_like ~context info = + (context.aggressive || body_size ~context info <= 15) + && (not info.recursive) + && (not (contains_loop ~context info)) + && returns_a_block ~context info + && count_init_code ~context info * 2 > body_size ~context info + && full_size ~context info - body_size ~context info <= 20 * closure_count ~context info + +let trivial_function ~context info = + body_size ~context info <= 1 && closure_count ~context info = 0 + +(* + We inline small functions which are simple (no closure, no + recursive) when one of the argument is a function that would get + inlined afterwards. +*) +let rec small_function ~context info args = + (not info.recursive) + && body_size ~context info <= 15 + && closure_count ~context info = 0 + && (not (List.is_empty args)) + && + let relevant_params = interesting_parameters ~context info in try - (* Ignore large functions *) - if size > 10 then raise Exit; - Code.preorder_traverse - { fold = Code.fold_children } - (fun pc () -> - let block = Addr.Map.find pc blocks in - (match block.branch with - (* We currenly disable inlining when raising and catching exception *) - | Poptrap _ | Pushtrap _ -> raise Exit - | Raise _ -> raise Exit - | Stop -> raise Exit - | Return x -> ( - match List.last block.body with - | None -> () - | Some (Let (y, Apply { f; _ })) -> - (* track if some params are called in tail position *) - if Code.Var.equal x y && List.mem f ~set:params - then tc := Var.Set.add f !tc - | Some _ -> ()) - | Branch _ | Cond _ | Switch _ -> ()); - List.iter block.body ~f:(fun i -> - match i with - (* We currenly don't want to duplicate Closure *) - | Let (_, Closure _) -> raise Exit - | _ -> ()); - Freevars.iter_block_bound_vars - (fun x -> bound_vars := Var.Set.add x !bound_vars) - block; - Freevars.iter_block_free_vars - (fun x -> - if not (Var.Set.mem x !bound_vars) - then - free_vars := - Var.Map.update - x - (function - | None -> Some 1 - | Some n -> Some (succ n)) - !free_vars) - block) - pc - blocks - (); - Some (!bound_vars, !free_vars, Var.Map.mem name !free_vars, !tc) - with Exit -> None + List.iter2 args info.params ~f:(fun arg param -> + if Var.Map.mem arg context.env && List.mem_assoc param ~map:relevant_params + then + let info' = Var.Map.find arg context.env in + let arity = List.assoc param relevant_params in + if + List.compare_length_with info'.params ~len:arity = 0 + && should_inline + ~context: + { context with + in_loop = context.in_loop || contains_loop ~context info + } + info' + [] + then raise Exit); + false + with Exit -> true + +and should_inline ~context info args = + (* A closure contains a pointer to (recursively) the contexts of its + enclosing functions. The context of a function contains the + variables bound in this function which are referred to from one + of the enclosed function. To limit the risk of memory leaks, we + don't inline functions containing closure if this makes these + closures capture additional contexts shared with other + closures. *) + (match Config.target (), Config.effects () with + | `JavaScript, (`Disabled | `Cps) -> + closure_count ~context info = 0 + || Option.is_none context.enclosing_function + || Option.equal Var.equal info.enclosing_function context.current_function + || (not !(context.has_closures)) + && Option.equal Var.equal info.enclosing_function context.enclosing_function + | `Wasm, _ | `JavaScript, `Double_translation -> true + | `JavaScript, `Jspi -> assert false) + && (functor_like ~context info + || (context.live_vars.(Var.idx info.f) = 1 + && + match Config.target () with + | `Wasm when context.in_loop -> + (* Avoid inlining in loop since, if the loop is not hot, the + code might never get optimized *) + body_size ~context info < 30 && not (contains_loop ~context info) + | `JavaScript + when Option.is_none context.current_function && contains_loop ~context info -> + (* Avoid inlining loops at toplevel since the toplevel + code is less likely to get optimized *) + false + | _ -> body_size ~context info < Config.Param.inlining_limit ()) + || trivial_function ~context info + || small_function ~context info args) + +let trace_inlining ~context info x args = + if debug () + then + let sz = body_size ~context info in + let sz' = full_size ~context info in + Format.eprintf + "%a <- %a%s: %b uses:%d size:%d/%d loop:%b rec:%b closures:%d init:%d \ + return_block:%b functor:%b small:%b@." + Var.print + x + Var.print + info.f + (match Var.get_name info.f with + | Some s -> "(" ^ s ^ ")" + | None -> "") + (should_inline ~context info args) + context.live_vars.(Var.idx info.f) + sz + sz' + (contains_loop ~context info) + info.recursive + (closure_count ~context info) + (count_init_code ~context info) + (returns_a_block ~context info) + (functor_like ~context info) + (small_function ~context info args) (****) -let optimizable blocks pc = +(* Inlining a function used only once will leave an unused closure + with an initial continuation pointing to a block belonging to + another function. This removes these closures. *) + +let remove_dead_closures_from_block ~live_vars p pc block = + let is_dead_closure i = + match i with + | Let (f, Closure _) -> + let f = Var.idx f in + f <= Array.length live_vars && live_vars.(f) = 0 + | _ -> false + in + if List.exists ~f:is_dead_closure block.body + then + { p with + blocks = + Addr.Map.add + pc + { block with + body = + List.fold_left block.body ~init:[] ~f:(fun acc i -> + match i, acc with + | Event _, Event _ :: prev -> + (* Avoid consecutive events (keep just the last one) *) + i :: prev + | _ -> if is_dead_closure i then acc else i :: acc) + |> List.rev + } + p.blocks + } + else p + +let remove_dead_closures ~live_vars p pc = Code.traverse - { fold = Code.fold_children } - (fun pc { size; optimizable } -> - let b = Addr.Map.find pc blocks in - let this_size = block_size b in - let optimizable = - optimizable - && List.for_all b.body ~f:(function - | Let (_, Prim (Extern "caml_js_eval_string", _)) -> false - | Let (_, Prim (Extern "debugger", _)) -> false - | Let - ( _ - , Prim (Extern ("caml_js_var" | "caml_js_expr" | "caml_pure_js_expr"), _) - ) -> - (* TODO: we should be smarter here and look the generated js *) - (* let's consider it this opmiziable *) - true - | _ -> true) - in - { optimizable; size = size + this_size }) + { fold = fold_children } + (fun pc p -> + let block = Addr.Map.find pc p.blocks in + remove_dead_closures_from_block ~live_vars p pc block) pc - blocks - { optimizable = true; size = 0 } - -let get_closures { blocks; _ } = - Addr.Map.fold - (fun _ block closures -> - List.fold_left block.body ~init:closures ~f:(fun closures i -> - match i with - | Let (x, Closure (cl_params, cl_cont, cl_loc)) -> - (* we can compute this once during the pass - as the property won't change with inlining *) - let cl_prop = optimizable blocks (fst cl_cont) in - let cl_simpl = - simple_function blocks cl_prop.size x cl_params (fst cl_cont) - in - Var.Map.add x { cl_params; cl_cont; cl_prop; cl_simpl; cl_loc } closures - | _ -> closures)) - blocks - Var.Map.empty + p.blocks + p (****) @@ -164,179 +489,143 @@ let rewrite_closure blocks cont_pc clos_pc = blocks blocks -(****) +let inline_function p rem branch x params cont args = + let blocks, cont_pc, free_pc = + match rem, branch with + | [], Return y when Var.equal x y -> + (* We do not need a continuation block for tail calls *) + p.blocks, None, p.free_pc + | _ -> + let fresh_addr = p.free_pc in + let free_pc = fresh_addr + 1 in + ( Addr.Map.add fresh_addr { params = [ x ]; body = rem; branch } p.blocks + , Some fresh_addr + , free_pc ) + in + let blocks = rewrite_closure blocks cont_pc (fst cont) in + (* We do not really need this intermediate block. + It just avoids the need to find which function + parameters are used in the function body. *) + let fresh_addr = free_pc in + let free_pc = fresh_addr + 1 in + assert (List.compare_lengths args params = 0); + let blocks = + Addr.Map.add fresh_addr { params; body = []; branch = Branch cont } blocks + in + [], (Branch (fresh_addr, args), { p with blocks; free_pc }) -let inline inline_count live_vars closures pc (outer, p) = - let block = Addr.Map.find pc p.blocks in - let body, (outer, branch, p) = +let inline_in_block ~context pc block p = + let body, (branch, p) = List.fold_right - block.body - ~init:([], (outer, block.branch, p)) ~f:(fun i (rem, state) -> match i with - | Let (x, Apply { f; args; exact = true; _ }) when Var.Map.mem f closures -> ( - let outer, branch, p = state in - let { cl_params = params - ; cl_cont = clos_cont - ; cl_prop = { size = f_size; optimizable = f_optimizable } - ; cl_simpl - ; cl_loc - } = - Var.Map.find f closures - in - let map_param_to_arg = - List.fold_left2 - ~f:(fun map a b -> Var.Map.add a b map) - ~init:Var.Map.empty - params - args - in - if - live_vars.(Var.idx f) = 1 - && Bool.equal outer.optimizable f_optimizable - (* Inlining the code of an optimizable function could - make this code unoptimized. (wrt to Jit compilers) *) - && f_size < Config.Param.inlining_limit () + | Let (x, Apply { f; args; exact = true; _ }) when Var.Map.mem f context.env -> + let info = Var.Map.find f context.env in + let { params; cont; _ } = info in + trace_inlining ~context info x args; + if should_inline ~context info args then ( - let blocks, cont_pc, free_pc = - match rem, branch with - | [], Return y when Var.compare x y = 0 -> - (* We do not need a continuation block for tail calls *) - p.blocks, None, p.free_pc - | _ -> - let fresh_addr = p.free_pc in - let free_pc = fresh_addr + 1 in - ( Addr.Map.add - fresh_addr - { params = [ x ]; body = rem; branch } - p.blocks - , Some fresh_addr - , free_pc ) - in - let blocks = rewrite_closure blocks cont_pc (fst clos_cont) in - (* We do not really need this intermediate block. - It just avoids the need to find which function - parameters are used in the function body. *) - let fresh_addr = free_pc in - let free_pc = fresh_addr + 1 in - let blocks = - Addr.Map.add - fresh_addr - { params; body = []; branch = Branch clos_cont } - blocks - in - let outer = { outer with size = outer.size + f_size } in - incr inline_count; - [], (outer, Branch (fresh_addr, args), { p with blocks; free_pc })) - else - match cl_simpl with - | Some (_, free_vars, recursive, tc_params) - (* We inline/duplicate - - single instruction functions (f_size = 1) - - small funtions that call one of their arguments in - tail position when the argument is a direct closure - used only once. *) - when (Code.Var.Set.exists - (fun x -> - let farg_tc = Var.Map.find x map_param_to_arg in - Var.Map.mem farg_tc closures && live_vars.(Var.idx farg_tc) = 1) - tc_params - || f_size <= 1) - && not recursive -> - let () = - (* Update live_vars *) - Var.Map.iter - (fun fv c -> - if not (Var.equal fv f) - then - let idx = Var.idx fv in - live_vars.(idx) <- live_vars.(idx) + c) - free_vars; - live_vars.(Var.idx f) <- live_vars.(Var.idx f) - 1 - in - let p, f, params, clos_cont = - Duplicate.closure p ~f ~params ~cont:clos_cont - in - if recursive - then - ( Let (f, Closure (params, clos_cont, cl_loc)) - :: Let (x, Apply { f; args; exact = true }) - :: rem - , (outer, branch, p) ) - else - let blocks, cont_pc, free_pc = - match rem, branch with - | [], Return y when Var.compare x y = 0 -> - (* We do not need a continuation block for tail calls *) - p.blocks, None, p.free_pc - | _ -> - let fresh_addr = p.free_pc in - let free_pc = fresh_addr + 1 in - ( Addr.Map.add - fresh_addr - { params = [ x ]; body = rem; branch } - p.blocks - , Some fresh_addr - , free_pc ) - in - let blocks = rewrite_closure blocks cont_pc (fst clos_cont) in - (* We do not really need this intermediate block. - It just avoids the need to find which function - parameters are used in the function body. *) - let fresh_addr = free_pc in - let free_pc = fresh_addr + 1 in - let blocks = - Addr.Map.add - fresh_addr - { params; body = []; branch = Branch clos_cont } - blocks - in - let outer = { outer with size = outer.size + f_size } in - incr inline_count; - [], (outer, Branch (fresh_addr, args), { p with blocks; free_pc }) - | _ -> i :: rem, state) + let branch, p = state in + incr context.inline_count; + if closure_count ~context info > 0 then context.has_closures := true; + context.live_vars.(Var.idx f) <- context.live_vars.(Var.idx f) - 1; + if context.live_vars.(Var.idx f) > 0 + then + let p, _, params, cont = Duplicate.closure p ~f ~params ~cont in + inline_function p rem branch x params cont args + else inline_function p rem branch x params cont args) + else i :: rem, state | _ -> i :: rem, state) + ~init:([], (block.branch, p)) + block.body in - outer, { p with blocks = Addr.Map.add pc { block with body; branch } p.blocks } - -(****) + { p with blocks = Addr.Map.add pc { block with body; branch } p.blocks } -let times = Debug.find "times" +let inline ~aggressive ~inline_count p ~live_vars = + if debug () then Format.eprintf "====== inlining ======@."; + (visit_closures + p + ~live_vars + (fun ~recursive + ~enclosing_function + ~current_function + ~params + ~cont:((pc, _) as cont) + (context : context) + -> + let p = context.p in + let has_closures = ref (closure_count_uncached ~context pc > 0) in + let in_loop = blocks_in_loop p pc in + let context = + { context with has_closures; enclosing_function; current_function } + in + let p = + Code.traverse + { fold = Code.fold_children } + (fun pc p -> + let block = Addr.Map.find pc p.blocks in + if + (* Skip blocks with no call of known function *) + List.for_all + ~f:(fun i -> + match i with + | Let (_, Apply { f; _ }) -> not (Var.Map.mem f context.env) + | _ -> true) + block.body + then p + else + inline_in_block + ~context:{ context with in_loop = Addr.Set.mem pc in_loop } + pc + block + p) + pc + p.blocks + p + in + let p = remove_dead_closures ~live_vars p pc in + let env = + match current_function with + | Some f -> + Var.Map.add + f + { f + ; params + ; cont + ; enclosing_function + ; recursive + ; loops = ref None + ; body_size = ref None + ; full_size = ref None + ; closure_count = ref None + ; init_code = ref None + ; returns_a_block = ref None + ; interesting_params = ref None + } + context.env + | None -> context.env + in + { context with p; env }) + { aggressive + ; p + ; live_vars + ; inline_count + ; env = Var.Map.empty + ; in_loop = false + ; has_closures = ref false + ; current_function = None + ; enclosing_function = None + }) + .p -let stats = Debug.find "stats" +(****) -let f p live_vars = - let inline_count = ref 0 in +let f ~aggressive p live_vars = Code.invariant p; + let inline_count = ref 0 in let t = Timer.make () in - let closures = get_closures p in - let _closures, p = - Code.fold_closures_innermost_first - p - (fun name cl_params (pc, _) _ (closures, p) -> - let traverse outer = - Code.traverse - { fold = Code.fold_children } - (inline inline_count live_vars closures) - pc - p.blocks - (outer, p) - in - match name with - | None -> - let _, p = traverse (optimizable p.blocks pc) in - closures, p - | Some x -> - let info = Var.Map.find x closures in - let outer, p = traverse info.cl_prop in - let cl_simpl = simple_function p.blocks outer.size x cl_params pc in - let closures = - Var.Map.add x { info with cl_prop = outer; cl_simpl } closures - in - closures, p) - (closures, p) - in + let p = inline ~aggressive ~inline_count p ~live_vars in if times () then Format.eprintf " inlining: %a@." Timer.print t; - if stats () then Format.eprintf "Stats - inline: %d optimizations@." !inline_count; + if stats () then Format.eprintf "Stats - inlining: %d inlined functions@." !inline_count; Code.invariant p; p diff --git a/compiler/lib/inline.mli b/compiler/lib/inline.mli index 9799e882a2..9a96b6a043 100644 --- a/compiler/lib/inline.mli +++ b/compiler/lib/inline.mli @@ -18,4 +18,4 @@ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *) -val f : Code.program -> Deadcode.variable_uses -> Code.program +val f : aggressive:bool -> Code.program -> Deadcode.variable_uses -> Code.program diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml index bcbf5cd20b..dbabd7f69d 100644 --- a/compiler/tests-compiler/global_deadcode.ml +++ b/compiler/tests-compiler/global_deadcode.ml @@ -93,6 +93,7 @@ let%expect_test "Omit unused fields" = compile_and_parse {| let f b x = + for i = 0 to 2 do prerr_endline "X" done; (* Prevent inlining *) let t = if b then (1, 2, x) else (3, x, 4) in let (u, _, v) = t in (u, v) From 60af8f7e59ef9305aed8ca3b60879356ff607cb0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Vouillon?= Date: Thu, 24 Apr 2025 17:02:49 +0200 Subject: [PATCH 5/7] Update tests --- compiler/tests-compiler/direct_calls.ml | 108 +- .../double-translation/direct_calls.ml | 124 +- .../double-translation/effects_toplevel.ml | 51 +- compiler/tests-compiler/effects_toplevel.ml | 58 +- compiler/tests-compiler/gh1320.ml | 24 +- compiler/tests-compiler/gh1559.ml | 98 +- compiler/tests-compiler/global_deadcode.ml | 12 +- compiler/tests-compiler/rec52.ml | 2 +- compiler/tests-full/stdlib.cma.expected.js | 3850 ++++++++--------- 9 files changed, 2074 insertions(+), 2253 deletions(-) diff --git a/compiler/tests-compiler/direct_calls.ml b/compiler/tests-compiler/direct_calls.ml index b2a700b490..ac298fbb52 100644 --- a/compiler/tests-compiler/direct_calls.ml +++ b/compiler/tests-compiler/direct_calls.ml @@ -56,46 +56,22 @@ let%expect_test "direct calls without --effects=cps" = print_fun_decl code (Some "test4"); [%expect {| - function test1(param){ - function f(g, x){ - try{caml_call1(g, x); return;} - catch(e$0){ - var e = caml_wrap_exception(e$0); - throw caml_maybe_attach_backtrace(e, 0); - } - } - f(function(x){return x + 1 | 0;}, 7); - f(function(x){return x * 2.;}, 4.); - return 0; - } + function test1(param){return 0;} //end function test2(param){ - function f(g, x){ - try{caml_call1(g, x); return;} - catch(e$0){ - var e = caml_wrap_exception(e$0); - throw caml_maybe_attach_backtrace(e, 0); - } + try{caml_call2(Stdlib[28], x, cst_a);} + catch(e$0){ + var e = caml_wrap_exception(e$0); + throw caml_maybe_attach_backtrace(e, 0); } - f(function(x){return x + 1 | 0;}, 7); - f(function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, cst_a); return 0; } //end - function test3(x){ - function F(symbol){function f(x){return x + 1 | 0;} return [0, f];} - var M1 = F([0]), M2 = F([0]), _b_ = M2[1].call(null, 2); - return [0, M1[1].call(null, 1), _b_]; - } + function test3(x){return [0, 2, 3];} //end function test4(x){ - function F(symbol){ - function f(x){return caml_call2(Stdlib_Printf[2], _a_, x);} - return [0, f]; - } - var M1 = F([0]), M2 = F([0]); - M1[1].call(null, 1); - return M2[1].call(null, 2); + caml_call2(Stdlib_Printf[2], _a_, 1); + return caml_call2(Stdlib_Printf[2], _a_, 2); } //end |}] @@ -138,64 +114,30 @@ let%expect_test "direct calls with --effects=cps" = print_fun_decl code (Some "test4"); [%expect {| - function test1(param, cont){ - function f(g, x){ - try{g(); return;} - catch(e$0){ - var e = caml_wrap_exception(e$0); - throw caml_maybe_attach_backtrace(e, 0); - } - } - f(function(x){}); - f(function(x){}); - return cont(0); - } + function test1(param, cont){return cont(0);} //end function test2(param, cont){ - function f(g, x, cont){ - runtime.caml_push_trap - (function(e){ - var raise = caml_pop_trap(), e$0 = caml_maybe_attach_backtrace(e, 0); - return raise(e$0); - }); - return caml_exact_trampoline_cps_call - (g, x, function(_t_){caml_pop_trap(); return cont();}); - } - return caml_exact_trampoline_cps_call$0 - (f, - function(x, cont){return cont();}, - 7, - function(_r_){ - return caml_exact_trampoline_cps_call$0 - (f, - function(x, cont){ - return caml_trampoline_cps_call3 - (Stdlib[28], x, cst_a$0, cont); - }, - cst_a, - function(_s_){return cont(0);}); - }); + runtime.caml_push_trap + (function(e){ + var raise = caml_pop_trap(), e$0 = caml_maybe_attach_backtrace(e, 0); + return raise(e$0); + }); + return caml_trampoline_cps_call3 + (Stdlib[28], + x, + cst_a, + function(_g_){caml_pop_trap(); return cont(0);}); } //end - function test3(x, cont){ - function F(symbol){function f(x){return x + 1 | 0;} return [0, f];} - var M1 = F(), M2 = F(), _q_ = M2[1].call(null, 2); - return cont([0, M1[1].call(null, 1), _q_]); - } + function test3(x, cont){return cont([0, 2, 3]);} //end function test4(x, cont){ - function F(symbol){ - function f(x, cont){ - return caml_trampoline_cps_call3(Stdlib_Printf[2], _o_, x, cont); - } - return [0, f]; - } - var M1 = F(), M2 = F(); - return caml_exact_trampoline_cps_call - (M1[1], + return caml_trampoline_cps_call3 + (Stdlib_Printf[2], + _e_, 1, - function(_p_){ - return caml_exact_trampoline_cps_call(M2[1], 2, cont); + function(_f_){ + return caml_trampoline_cps_call3(Stdlib_Printf[2], _e_, 2, cont); }); } //end diff --git a/compiler/tests-compiler/double-translation/direct_calls.ml b/compiler/tests-compiler/double-translation/direct_calls.ml index 9f40e8a28e..857ec50cc0 100644 --- a/compiler/tests-compiler/double-translation/direct_calls.ml +++ b/compiler/tests-compiler/double-translation/direct_calls.ml @@ -121,103 +121,47 @@ let%expect_test "direct calls with --effects=double-translation" = : runtime.caml_call_gen(f, [a0, a1])) : runtime.caml_trampoline_return(f, [a0, a1, a2], 0); } - function caml_exact_trampoline_cps_call$0(f, a0, a1, a2){ - return runtime.caml_stack_check_depth() - ? f.cps ? f.cps.call(null, a0, a1, a2) : a2(f(a0, a1)) - : runtime.caml_trampoline_return(f, [a0, a1, a2], 0); - } var - dummy = 0, global_data = runtime.caml_get_global_data(), - _z_ = [0, [4, 0, 0, 0, 0], caml_string_of_jsbytes("%d")], - cst_a$0 = caml_string_of_jsbytes("a"), + _k_ = [0, [4, 0, 0, 0, 0], caml_string_of_jsbytes("%d")], cst_a = caml_string_of_jsbytes("a"), + x = caml_string_of_jsbytes("a"), Stdlib = global_data.Stdlib, Stdlib_Printf = global_data.Stdlib__Printf; - function test1(param){ - function f(g, x){ - try{caml_call1(g, dummy); return;} - catch(e$0){ - var e = caml_wrap_exception(e$0); - throw caml_maybe_attach_backtrace(e, 0); - } - } - f(function(x){}); - f(function(x){}); - return 0; - } - function f$0(){ - function f$0(g, x){ - try{caml_call1(g, x); return;} - catch(e$0){ - var e = caml_wrap_exception(e$0); - throw caml_maybe_attach_backtrace(e, 0); - } - } - function f$1(g, x, cont){ - runtime.caml_push_trap - (function(e$0){ - var raise = caml_pop_trap(), e = caml_maybe_attach_backtrace(e$0, 0); - return raise(e); - }); - return caml_exact_trampoline_cps_call - (g, x, function(_K_){caml_pop_trap(); return cont();}); - } - var f = caml_cps_closure(f$0, f$1); - return f; - } - function _h_(){return function(x){};} - function _j_(){ - return caml_cps_closure - (function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, - function(x, cont){ - return caml_trampoline_cps_call3(Stdlib[28], x, cst_a$0, cont); - }); - } + function test1(param){return 0;} function test2$0(param){ - var f = f$0(); - f(_h_(), 7); - f(_j_(), cst_a); + try{caml_call2(Stdlib[28], x, cst_a);} + catch(e$0){ + var e = caml_wrap_exception(e$0); + throw caml_maybe_attach_backtrace(e, 0); + } return 0; } function test2$1(param, cont){ - var f = f$0(); - return caml_exact_trampoline_cps_call$0 - (f, - _h_(), - 7, - function(_I_){ - return caml_exact_trampoline_cps_call$0 - (f, _j_(), cst_a, function(_J_){return cont(0);}); - }); + runtime.caml_push_trap + (function(e$0){ + var raise = caml_pop_trap(), e = caml_maybe_attach_backtrace(e$0, 0); + return raise(e); + }); + return caml_trampoline_cps_call3 + (Stdlib[28], + x, + cst_a, + function(_s_){caml_pop_trap(); return cont(0);}); } var test2 = caml_cps_closure(test2$0, test2$1); - function test3(x){ - function F(symbol){function f(x){return x + 1 | 0;} return [0, f];} - var M1 = F(), M2 = F(), _H_ = caml_call1(M2[1], 2); - return [0, caml_call1(M1[1], 1), _H_]; - } - function f(){ - function f$0(x){return caml_call2(Stdlib_Printf[2], _z_, x);} - function f$1(x, cont){ - return caml_trampoline_cps_call3(Stdlib_Printf[2], _z_, x, cont); - } - var f = caml_cps_closure(f$0, f$1); - return f; - } - function F(){function F(symbol){var f$0 = f(); return [0, f$0];} return F;} + function test3(x){return [0, 2, 3];} function test4$0(x){ - var F$0 = F(), M1 = F$0(), M2 = F$0(); - caml_call1(M1[1], 1); - return caml_call1(M2[1], 2); + caml_call2(Stdlib_Printf[2], _k_, 1); + return caml_call2(Stdlib_Printf[2], _k_, 2); } function test4$1(x, cont){ - var F$0 = F(), M1 = F$0(), M2 = F$0(); - return caml_exact_trampoline_cps_call - (M1[1], + return caml_trampoline_cps_call3 + (Stdlib_Printf[2], + _k_, 1, - function(_G_){ - return caml_exact_trampoline_cps_call(M2[1], 2, cont); + function(_r_){ + return caml_trampoline_cps_call3(Stdlib_Printf[2], _k_, 2, cont); }); } var test4 = caml_cps_closure(test4$0, test4$1); @@ -233,18 +177,18 @@ let%expect_test "direct calls with --effects=double-translation" = tuple = recfuncs(x), f = tuple[2], h = tuple[1], - _E_ = h(100), - _F_ = f(12) + _E_ | 0; - return caml_call1(Stdlib[44], _F_); + _p_ = h(100), + _q_ = f(12) + _p_ | 0; + return caml_call1(Stdlib[44], _q_); } function g$1(x, cont){ var tuple = recfuncs(x), f = tuple[2], h = tuple[1], - _C_ = h(100), - _D_ = f(12) + _C_ | 0; - return caml_trampoline_cps_call2(Stdlib[44], _D_, cont); + _n_ = h(100), + _o_ = f(12) + _n_ | 0; + return caml_trampoline_cps_call2(Stdlib[44], _o_, cont); } var g = caml_cps_closure(g$0, g$1); return g; @@ -255,9 +199,9 @@ let%expect_test "direct calls with --effects=double-translation" = return caml_exact_trampoline_cps_call (g$0, 42, - function(_A_){ + function(_l_){ return caml_exact_trampoline_cps_call - (g$0, - 5, function(_B_){return cont(0);}); + (g$0, - 5, function(_m_){return cont(0);}); }); } var diff --git a/compiler/tests-compiler/double-translation/effects_toplevel.ml b/compiler/tests-compiler/double-translation/effects_toplevel.ml index 83f618e0a2..1f194000df 100644 --- a/compiler/tests-compiler/double-translation/effects_toplevel.ml +++ b/compiler/tests-compiler/double-translation/effects_toplevel.ml @@ -38,12 +38,18 @@ let%expect_test "test-compiler/lib-effects/test1.ml" = "use strict"; var runtime = globalThis.jsoo_runtime, + caml_cps_closure = runtime.caml_cps_closure, caml_string_of_jsbytes = runtime.caml_string_of_jsbytes; function caml_call1(f, a0){ return (f.l >= 0 ? f.l : f.l = f.length) === 1 ? f(a0) : runtime.caml_call_gen(f, [a0]); } + function caml_exact_trampoline_call1(f, a0){ + return runtime.caml_stack_check_depth() + ? f(a0) + : runtime.caml_trampoline_return(f, [a0], 1); + } function caml_trampoline_cps_call2(f, a0, a1){ return runtime.caml_stack_check_depth() ? f.cps @@ -60,32 +66,47 @@ let%expect_test "test-compiler/lib-effects/test1.ml" = : runtime.caml_call_gen(f, [a0])) : runtime.caml_trampoline_return(f, [a0, a1], 0); } + function caml_exact_trampoline_cps_call(f, a0, a1){ + return runtime.caml_stack_check_depth() + ? f.cps ? f.cps.call(null, a0, a1) : a1(f(a0)) + : runtime.caml_trampoline_return(f, [a0, a1], 0); + } var dummy = 0, global_data = runtime.caml_get_global_data(), - _b_ = + _c_ = [0, [11, caml_string_of_jsbytes("abc"), 0], caml_string_of_jsbytes("abc")], Stdlib_Printf = global_data.Stdlib__Printf; - function g$0(param){return caml_call1(Stdlib_Printf[2], _b_);} + function g$0(param){return caml_call1(Stdlib_Printf[2], _c_);} function g$1(param, cont){ - return caml_trampoline_cps_call2(Stdlib_Printf[2], _b_, cont); + return caml_trampoline_cps_call2(Stdlib_Printf[2], _c_, cont); } - var g = runtime.caml_cps_closure(g$0, g$1); - g(); - var i = 1; - for(;;){ - g(); - var _c_ = i + 1 | 0; - if(5 === i){ - g(); - var Test = [0]; - runtime.caml_register_global(2, Test, "Test"); - return; + var g = caml_cps_closure(g$0, g$1); + function f$0(param){ + var i = 1; + for(;;){g(); var _g_ = i + 1 | 0; if(5 === i) return; i = _g_;} + } + function f$1(param, cont){ + function _d_(i){ + return caml_exact_trampoline_cps_call + (g, + dummy, + function(_f_){ + var _e_ = i + 1 | 0; + return 5 !== i ? caml_exact_trampoline_call1(_d_, _e_) : cont(); + }); } - i = _c_; + return _d_(1); } + var f = caml_cps_closure(f$0, f$1); + g(); + f(); + g(); + var Test = [0]; + runtime.caml_register_global(2, Test, "Test"); + return; } (globalThis)); //end diff --git a/compiler/tests-compiler/effects_toplevel.ml b/compiler/tests-compiler/effects_toplevel.ml index 6faf1ef7b0..eaa1eef0ce 100644 --- a/compiler/tests-compiler/effects_toplevel.ml +++ b/compiler/tests-compiler/effects_toplevel.ml @@ -61,35 +61,35 @@ let%expect_test "test-compiler/lib-effects/test1.ml" = ? f(a0, a1) : runtime.caml_trampoline_return(f, [a0, a1], 0); } - return caml_callback - (function(cont){ - var - dummy = 0, - global_data = runtime.caml_get_global_data(), - Stdlib_Printf = global_data.Stdlib__Printf, - _b_ = - [0, - [11, caml_string_of_jsbytes("abc"), 0], - caml_string_of_jsbytes("abc")]; - function g(param, cont){ - return caml_trampoline_cps_call2(Stdlib_Printf[2], _b_, cont); - } - caml_callback(g, [dummy]); - function _c_(i){ - return caml_exact_trampoline_cps_call - (g, - dummy, - function(_d_){ - var _e_ = i + 1 | 0; - if(5 !== i) return caml_exact_trampoline_call1(_c_, _e_); - caml_callback(g, [dummy]); - var Test = [0]; - runtime.caml_register_global(2, Test, "Test"); - }); - } - return _c_(1); - }, - []); + var + dummy = 0, + global_data = runtime.caml_get_global_data(), + Stdlib_Printf = global_data.Stdlib__Printf, + _c_ = + [0, + [11, caml_string_of_jsbytes("abc"), 0], + caml_string_of_jsbytes("abc")]; + function g(param, cont){ + return caml_trampoline_cps_call2(Stdlib_Printf[2], _c_, cont); + } + function f(param, cont){ + function _d_(i){ + return caml_exact_trampoline_cps_call + (g, + dummy, + function(_e_){ + var _f_ = i + 1 | 0; + return 5 !== i ? caml_exact_trampoline_call1(_d_, _f_) : cont(); + }); + } + return _d_(1); + } + caml_callback(g, [dummy]); + caml_callback(f, [dummy]); + caml_callback(g, [dummy]); + var Test = [0]; + runtime.caml_register_global(2, Test, "Test"); + return; } (globalThis)); //end diff --git a/compiler/tests-compiler/gh1320.ml b/compiler/tests-compiler/gh1320.ml index b29ce75b07..53f63e0954 100644 --- a/compiler/tests-compiler/gh1320.ml +++ b/compiler/tests-compiler/gh1320.ml @@ -48,17 +48,23 @@ let () = myfun () for(;;){ let i$0 = i; var - f = + g = function(x){ - return 0 === x ? 1 : runtime.caml_mul(i$0, app(g$0, x - 1 | 0)); - }, - g = function(x){return app(f$0, x);}; - let f$0 = f, g$0 = g; - var _c_ = app(f, i); - caml_call2(Stdlib_Printf[3], _a_, _c_); - var _b_ = i + 1 | 0; + try{ + var _d_ = 0 === x ? 1 : runtime.caml_mul(i$0, app(g$0, x - 1 | 0)); + return _d_; + } + catch(e$0){ + var e = caml_wrap_exception(e$0); + throw caml_maybe_attach_backtrace(e, 0); + } + }; + let g$0 = g; + var _b_ = g(i); + caml_call2(Stdlib_Printf[3], _a_, _b_); + var _c_ = i + 1 | 0; if(4 === i) return 0; - i = _b_; + i = _c_; } } //end |}] diff --git a/compiler/tests-compiler/gh1559.ml b/compiler/tests-compiler/gh1559.ml index 9f83d8b258..ea9d1a6ea0 100644 --- a/compiler/tests-compiler/gh1559.ml +++ b/compiler/tests-compiler/gh1559.ml @@ -81,32 +81,33 @@ let () = my_ref := 2 } var global_data = runtime.caml_get_global_data(), - t$0 = [0, 0], + t = [0, 0], init = [0, 1], Stdlib_Int = global_data.Stdlib__Int, Stdlib = global_data.Stdlib, my_ref = [0, 1], nesting = 1; - a: - { - var t = init; + function handle_state(t$0){ + var t$1 = t$0; for(;;){ - let t$1 = t; + let t$0 = t$1; var this_will_be_undefined = - function(param){var _c_ = 1 === t$1[1] ? 1 : 0; return _c_ ? 1 : 2;}, - i = t[1]; - if(0 === i){var _a_ = this_will_be_undefined(0); break a;} - if(1 === i) break; - t = t$0; + function(param){ + a: + {if(t$0 && 1 === t$0[1]){var _c_ = 1; break a;} var _c_ = 0;} + return _c_ ? 1 : 2; + }; + if(t$1) var i = t$1[1], match = i; else var match = - 1; + if(0 === match) return this_will_be_undefined(0); + if(1 === match) + return caml_call2(Stdlib_Int[8], nesting, 0) + ? nesting + : this_will_be_undefined(0); + t$1 = t; } - var - _a_ = - caml_call2(Stdlib_Int[8], nesting, 0) - ? nesting - : this_will_be_undefined(0); } - var _b_ = caml_call1(Stdlib_Int[12], _a_); + var _a_ = handle_state(init), _b_ = caml_call1(Stdlib_Int[12], _a_); caml_call1(Stdlib[46], _b_); my_ref[1] = 2; var Test = [0, my_ref]; @@ -186,49 +187,48 @@ let () = my_ref := 2 } var global_data = runtime.caml_get_global_data(), - t$0 = [0, 0], + t = [0, 0], init = [0, 1], Stdlib_Random = global_data.Stdlib__Random, Stdlib_Int = global_data.Stdlib__Int, Stdlib = global_data.Stdlib, my_ref = [0, 1], nesting = 1; - a: - { - b: - { - var t = init; - for(;;){ - let t$1 = t; + function handle_state(t$0){ + var t$1 = t$0; + for(;;){ + let t$0 = t$1; + var + this_will_be_undefined = + function(param){ + a: + {if(t$0 && 1 === t$0[1]){var _e_ = 1; break a;} var _e_ = 0;} + return _e_ ? 1 : 2; + }; + if(t$1) var i = t$1[1], match = i; else var match = - 1; + if(0 === match){ var - this_will_be_undefined = - function(param){var _e_ = 1 === t$1[1] ? 1 : 0; return _e_ ? 1 : 2;}, - i = t[1]; - if(0 === i) break; - if(1 === i) break b; - t = t$0; + g = function(param){return 2 + this_will_be_undefined(0) | 0;}, + _c_ = g(0); + return g(0) + _c_ | 0; } - var - g = function(param){return 2 + this_will_be_undefined(0) | 0;}, - _a_ = g(0), - _c_ = g(0) + _a_ | 0; - break a; + if(1 === match){ + if(caml_call2(Stdlib_Int[8], nesting, 0)) return nesting; + var + g$0 = + function(param){ + return 1 < caml_call1(Stdlib_Random[5], 3) + ? 2 + this_will_be_undefined(0) | 0 + : 1; + }, + _d_ = g$0(0); + return g$0(0) + _d_ | 0; + } + t$1 = t; } - if(caml_call2(Stdlib_Int[8], nesting, 0)) - var _c_ = nesting; - else - var - g$0 = - function(param){ - return 1 < caml_call1(Stdlib_Random[5], 3) - ? 2 + this_will_be_undefined(0) | 0 - : 1; - }, - _b_ = g$0(0), - _c_ = g$0(0) + _b_ | 0; } - var _d_ = caml_call1(Stdlib_Int[12], _c_); - caml_call1(Stdlib[46], _d_); + var _a_ = handle_state(init), _b_ = caml_call1(Stdlib_Int[12], _a_); + caml_call1(Stdlib[46], _b_); my_ref[1] = 2; var Test = [0, my_ref]; runtime.caml_register_global(5, Test, "Test"); diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml index dbabd7f69d..e57d38f251 100644 --- a/compiler/tests-compiler/global_deadcode.ml +++ b/compiler/tests-compiler/global_deadcode.ml @@ -105,8 +105,16 @@ let%expect_test "Omit unused fields" = [%expect {| function f(b, x){ - var t = b ? [0, 1, , x] : [0, 3, , 4], v = t[3], u = t[1]; - return [0, u, v]; + var i = 0; + for(;;){ + caml_call1(Stdlib[53], cst_X); + var _c_ = i + 1 | 0; + if(2 === i){ + var t = b ? [0, 1, , x] : [0, 3, , 4], v = t[3], u = t[1]; + return [0, u, v]; + } + i = _c_; + } } //end |}] diff --git a/compiler/tests-compiler/rec52.ml b/compiler/tests-compiler/rec52.ml index 87e13f1e32..ea3d01c3d5 100644 --- a/compiler/tests-compiler/rec52.ml +++ b/compiler/tests-compiler/rec52.ml @@ -70,7 +70,7 @@ let%expect_test "let rec" = default$0 = 42; function a(x){return b(x);} function b(x){ - var _a_ = b(0); + var _a_ = a(0); return [0, 84, [0, letrec_function_context[1], c, _a_]]; } var tbl = caml_call2(Stdlib_Hashtbl[1], 0, 17); diff --git a/compiler/tests-full/stdlib.cma.expected.js b/compiler/tests-full/stdlib.cma.expected.js index d53d538723..829a4cb6e2 100644 --- a/compiler/tests-full/stdlib.cma.expected.js +++ b/compiler/tests-full/stdlib.cma.expected.js @@ -1666,8 +1666,8 @@ var next = /*<>*/ match[2], x = match[1]; /*<>*/ return [0, x, - function(_au_){ - /*<>*/ return append(next, seq2, _au_); + function(_aE_){ + /*<>*/ return append(next, seq2, _aE_); }] /*<>*/ ; /*<>*/ } function map(f, seq, param){ @@ -1676,7 +1676,7 @@ var next = /*<>*/ match[2], x = match[1]; /*<>*/ return [0, caml_call1(f, x), - function(_at_){ /*<>*/ return map(f, next, _at_);}] /*<>*/ ; + function(_aD_){ /*<>*/ return map(f, next, _aD_);}] /*<>*/ ; /*<>*/ } function filter_map(f, seq$0, param){ var seq = /*<>*/ seq$0; @@ -1693,8 +1693,8 @@ var y = /*<>*/ match$0[1]; /*<>*/ return [0, y, - function(_as_){ - /*<>*/ return filter_map(f, next, _as_); + function(_aC_){ + /*<>*/ return filter_map(f, next, _aC_); }] /*<>*/ ; /*<>*/ } function filter(f, seq$0, param){ @@ -1708,8 +1708,8 @@ } /*<>*/ return [0, x, - function(_ar_){ - /*<>*/ return filter(f, next, _ar_); + function(_aB_){ + /*<>*/ return filter(f, next, _aB_); }] /*<>*/ ; /*<>*/ } function concat(seq, param){ @@ -1718,7 +1718,7 @@ var next = /*<>*/ match[2], x = match[1]; /*<>*/ return append (x, - function(_aq_){ /*<>*/ return concat(next, _aq_);}, + function(_aA_){ /*<>*/ return concat(next, _aA_);}, 0) /*<>*/ ; } function flat_map(f, seq, param){ @@ -1727,8 +1727,8 @@ var next = /*<>*/ match[2], x = match[1]; /*<>*/ return /*<>*/ append ( /*<>*/ caml_call1(f, x), - function(_ap_){ - /*<>*/ return flat_map(f, next, _ap_); + function(_az_){ + /*<>*/ return flat_map(f, next, _az_); }, 0) /*<>*/ ; } @@ -1764,7 +1764,7 @@ x = match$0[1]; /*<>*/ return [0, x, - function(_ao_){ /*<>*/ return unfold(f, u$0, _ao_);}] /*<>*/ ; + function(_ay_){ /*<>*/ return unfold(f, u$0, _ay_);}] /*<>*/ ; /*<>*/ } function is_empty(xs){ /*<>*/ return caml_call1(xs, 0) ? 0 : 1 /*<>*/ ; @@ -1822,8 +1822,8 @@ var xs$0 = /*<>*/ match[2], x = match[1], - _an_ = /*<>*/ caml_call1(p, x); - /*<>*/ if(! _an_) return _an_; + _ax_ = /*<>*/ caml_call1(p, x); + /*<>*/ if(! _ax_) return _ax_; xs = xs$0; } /*<>*/ } @@ -1835,8 +1835,8 @@ var xs$0 = /*<>*/ match[2], x = match[1], - _am_ = /*<>*/ caml_call1(p, x); - /*<>*/ if(_am_) return _am_; + _aw_ = /*<>*/ caml_call1(p, x); + /*<>*/ if(_aw_) return _aw_; xs = xs$0; } /*<>*/ } @@ -1940,8 +1940,8 @@ var ys$0 = /*<>*/ match$0[2], y = match$0[1], - _al_ = /*<>*/ caml_call2(f, x, y); - /*<>*/ if(! _al_) return _al_; + _av_ = /*<>*/ caml_call2(f, x, y); + /*<>*/ if(! _av_) return _av_; xs = xs$0; ys = ys$0; } @@ -1959,8 +1959,8 @@ var ys$0 = /*<>*/ match$0[2], y = match$0[1], - _ak_ = /*<>*/ caml_call2(f, x, y); - /*<>*/ if(_ak_) return _ak_; + _au_ = /*<>*/ caml_call2(f, x, y); + /*<>*/ if(_au_) return _au_; xs = xs$0; ys = ys$0; } @@ -1978,8 +1978,8 @@ y = match$0[1], xs$0 = match[2], x = match[1], - _aj_ = /*<>*/ caml_call2(eq, x, y); - /*<>*/ if(! _aj_) return _aj_; + _at_ = /*<>*/ caml_call2(eq, x, y); + /*<>*/ if(! _at_) return _at_; xs = xs$0; ys = ys$0; continue; @@ -2010,35 +2010,35 @@ /*<>*/ } function init_aux(f, i, j, param){ /*<>*/ if(i >= j) /*<>*/ return 0; - var _ah_ = /*<>*/ i + 1 | 0; + var _ar_ = /*<>*/ i + 1 | 0; /*<>*/ return [0, caml_call1(f, i), - function(_ai_){ - /*<>*/ return init_aux(f, _ah_, j, _ai_); + function(_as_){ + /*<>*/ return init_aux(f, _ar_, j, _as_); }] /*<>*/ ; /*<>*/ } function init(n, f){ /*<>*/ if(0 > n) /*<>*/ return caml_call1(Stdlib[1], cst_Seq_init) /*<>*/ ; - var _af_ = /*<>*/ 0; - return function(_ag_){ - /*<>*/ return init_aux(f, _af_, n, _ag_);} /*<>*/ ; + var _ap_ = /*<>*/ 0; + return function(_aq_){ + /*<>*/ return init_aux(f, _ap_, n, _aq_);} /*<>*/ ; /*<>*/ } function repeat(x, param){ /*<>*/ return [0, x, - function(_ae_){ /*<>*/ return repeat(x, _ae_);}] /*<>*/ ; + function(_ao_){ /*<>*/ return repeat(x, _ao_);}] /*<>*/ ; /*<>*/ } function forever(f, param){ /*<>*/ return [0, caml_call1(f, 0), - function(_ad_){ /*<>*/ return forever(f, _ad_);}] /*<>*/ ; + function(_an_){ /*<>*/ return forever(f, _an_);}] /*<>*/ ; /*<>*/ } function cycle_nonempty(xs, param){ /*<>*/ return append (xs, - function(_ac_){ - /*<>*/ return cycle_nonempty(xs, _ac_); + function(_am_){ + /*<>*/ return cycle_nonempty(xs, _am_); }, 0) /*<>*/ ; } @@ -2046,24 +2046,26 @@ var match = /*<>*/ caml_call1(xs, 0); /*<>*/ if(! match) /*<>*/ return 0; var xs$0 = /*<>*/ match[2], x = match[1]; - function _$_(_ab_){ - /*<>*/ return cycle_nonempty(xs, _ab_); + function _aj_(_al_){ + /*<>*/ return cycle_nonempty(xs, _al_); } /*<>*/ return [0, x, - function(_aa_){ - /*<>*/ return append(xs$0, _$_, _aa_); + function(_ak_){ + /*<>*/ return append(xs$0, _aj_, _ak_); }] /*<>*/ ; /*<>*/ } function iterate1(f, x, param){ var y = /*<>*/ caml_call1(f, x); /*<>*/ return [0, y, - function(___){ /*<>*/ return iterate1(f, y, ___);}] /*<>*/ ; + function(_ai_){ + /*<>*/ return iterate1(f, y, _ai_); + }] /*<>*/ ; /*<>*/ } function iterate(f, x){ - function next(_Z_){ /*<>*/ return iterate1(f, x, _Z_);} - /*<>*/ return function(_Y_){ + function next(_ah_){ /*<>*/ return iterate1(f, x, _ah_);} + /*<>*/ return function(_ag_){ /*<>*/ return [0, x, next];} /*<>*/ ; } function mapi_aux(f, i, xs, param){ @@ -2072,17 +2074,17 @@ var xs$0 = /*<>*/ match[2], x = match[1], - _W_ = /*<>*/ i + 1 | 0; + _ae_ = /*<>*/ i + 1 | 0; /*<>*/ return [0, caml_call2(f, i, x), - function(_X_){ - /*<>*/ return mapi_aux(f, _W_, xs$0, _X_); + function(_af_){ + /*<>*/ return mapi_aux(f, _ae_, xs$0, _af_); }] /*<>*/ ; /*<>*/ } function mapi(f, xs){ - var _U_ = /*<>*/ 0; - return function(_V_){ - /*<>*/ return mapi_aux(f, _U_, xs, _V_);} /*<>*/ ; + var _ac_ = /*<>*/ 0; + return function(_ad_){ + /*<>*/ return mapi_aux(f, _ac_, xs, _ad_);} /*<>*/ ; /*<>*/ } function tail_scan(f, s, xs, param){ var match = /*<>*/ caml_call1(xs, 0); @@ -2093,13 +2095,15 @@ s$0 = /*<>*/ caml_call2(f, s, x); /*<>*/ return [0, s$0, - function(_T_){ - /*<>*/ return tail_scan(f, s$0, xs$0, _T_); + function(_ab_){ + /*<>*/ return tail_scan(f, s$0, xs$0, _ab_); }] /*<>*/ ; /*<>*/ } function scan(f, s, xs){ - function next(_S_){ /*<>*/ return tail_scan(f, s, xs, _S_);} - /*<>*/ return function(_R_){ + function next(_aa_){ + /*<>*/ return tail_scan(f, s, xs, _aa_); + } + /*<>*/ return function(_$_){ /*<>*/ return [0, s, next];} /*<>*/ ; } function take_aux(n, xs){ @@ -2149,8 +2153,8 @@ /*<>*/ return caml_call1(p, x) ? [0, x, - function(_Q_){ - /*<>*/ return take_while(p, xs$0, _Q_); + function(___){ + /*<>*/ return take_while(p, xs$0, ___); }] : 0 /*<>*/ ; } @@ -2171,17 +2175,17 @@ var xs$0 = /*<>*/ match[2], x = match[1], - _J_ = /*<>*/ caml_call1(eq, x); - function _K_(_P_){ - /*<>*/ return drop_while(_J_, xs$0, _P_); + _T_ = /*<>*/ caml_call1(eq, x); + function _U_(_Z_){ + /*<>*/ return drop_while(_T_, xs$0, _Z_); } - var _L_ = /*<>*/ caml_call1(eq, x); - function next(_O_){ - /*<>*/ return take_while(_L_, xs$0, _O_); + var _V_ = /*<>*/ caml_call1(eq, x); + function next(_Y_){ + /*<>*/ return take_while(_V_, xs$0, _Y_); } /*<>*/ return [0, - function(_N_){ /*<>*/ return [0, x, next];}, - function(_M_){ /*<>*/ return group(eq, _K_, _M_);}] /*<>*/ ; + function(_X_){ /*<>*/ return [0, x, next];}, + function(_W_){ /*<>*/ return group(eq, _U_, _W_);}] /*<>*/ ; /*<>*/ } var Forced_twice = @@ -2200,9 +2204,9 @@ /*<>*/ } var s = /*<>*/ caml_call1(to_lazy, s$0); /*<>*/ return function(param){ - var _I_ = /*<>*/ runtime.caml_obj_tag(s); - if(250 === _I_) return s[1]; - if(246 !== _I_ && 244 !== _I_) return s; + var _S_ = /*<>*/ runtime.caml_obj_tag(s); + if(250 === _S_) return s[1]; + if(246 !== _S_ && 244 !== _S_) return s; return caml_call1(CamlinternalLazy[2], s) /*<>*/ ;} /*<>*/ ; /*<>*/ } function once(xs){ @@ -2229,7 +2233,7 @@ var ys$0 = /*<>*/ match$0[2], y = match$0[1]; /*<>*/ return [0, [0, x, y], - function(_H_){ /*<>*/ return zip(xs$0, ys$0, _H_);}] /*<>*/ ; + function(_R_){ /*<>*/ return zip(xs$0, ys$0, _R_);}] /*<>*/ ; /*<>*/ } function map2(f, xs, ys, param){ var match = /*<>*/ caml_call1(xs, 0); @@ -2242,8 +2246,8 @@ var ys$0 = /*<>*/ match$0[2], y = match$0[1]; /*<>*/ return [0, caml_call2(f, x, y), - function(_G_){ - /*<>*/ return map2(f, xs$0, ys$0, _G_); + function(_Q_){ + /*<>*/ return map2(f, xs$0, ys$0, _Q_); }] /*<>*/ ; /*<>*/ } function interleave(xs, ys, param){ @@ -2253,15 +2257,15 @@ var xs$0 = /*<>*/ match[2], x = match[1]; /*<>*/ return [0, x, - function(_F_){ - /*<>*/ return interleave(ys, xs$0, _F_); + function(_P_){ + /*<>*/ return interleave(ys, xs$0, _P_); }] /*<>*/ ; /*<>*/ } function sorted_merge1(cmp, x, xs, y, ys){ /*<>*/ return 0 < caml_call2(cmp, x, y) ? [0, y, - function(_D_){ + function(_N_){ var match = /*<>*/ caml_call1(ys, 0); /*<>*/ if(! match) /*<>*/ return [0, x, xs]; @@ -2270,7 +2274,7 @@ }] : [0, x, - function(_E_){ + function(_O_){ var match = /*<>*/ caml_call1(xs, 0); /*<>*/ if(! match) /*<>*/ return [0, y, ys]; @@ -2301,7 +2305,7 @@ var xys$0 = /*<>*/ match[2], x = match[1][1]; /*<>*/ return [0, x, - function(_C_){ /*<>*/ return map_fst(xys$0, _C_);}] /*<>*/ ; + function(_M_){ /*<>*/ return map_fst(xys$0, _M_);}] /*<>*/ ; /*<>*/ } function map_snd(xys, param){ var match = /*<>*/ caml_call1(xys, 0); @@ -2309,12 +2313,12 @@ var xys$0 = /*<>*/ match[2], y = match[1][2]; /*<>*/ return [0, y, - function(_B_){ /*<>*/ return map_snd(xys$0, _B_);}] /*<>*/ ; + function(_L_){ /*<>*/ return map_snd(xys$0, _L_);}] /*<>*/ ; /*<>*/ } function unzip(xys){ /*<>*/ return [0, - function(_A_){ /*<>*/ return map_fst(xys, _A_);}, - function(_z_){ /*<>*/ return map_snd(xys, _z_);}] /*<>*/ ; + function(_K_){ /*<>*/ return map_fst(xys, _K_);}, + function(_J_){ /*<>*/ return map_snd(xys, _J_);}] /*<>*/ ; /*<>*/ } function filter_map_find_left_map(f, xs$1, param){ var xs = /*<>*/ xs$1; @@ -2331,9 +2335,9 @@ var y = /*<>*/ match$0[1]; /*<>*/ return [0, y, - function(_y_){ + function(_I_){ /*<>*/ return filter_map_find_left_map - (f, xs$0, _y_); + (f, xs$0, _I_); }] /*<>*/ ; /*<>*/ } function filter_map_find_right_map(f, xs$1, param){ @@ -2351,47 +2355,44 @@ var z = /*<>*/ match$0[1]; /*<>*/ return [0, z, - function(_x_){ + function(_H_){ /*<>*/ return filter_map_find_right_map - (f, xs$0, _x_); + (f, xs$0, _H_); }] /*<>*/ ; /*<>*/ } function partition_map(f, xs){ /*<>*/ return [0, - function(_w_){ - /*<>*/ return filter_map_find_left_map(f, xs, _w_); + function(_G_){ + /*<>*/ return filter_map_find_left_map(f, xs, _G_); }, - function(_v_){ + function(_F_){ /*<>*/ return filter_map_find_right_map - (f, xs, _v_); + (f, xs, _F_); }] /*<>*/ ; /*<>*/ } function partition(p, xs){ - function _s_(x){ + function _C_(x){ /*<>*/ return 1 - caml_call1(p, x) /*<>*/ ; } /*<>*/ return [0, - function(_u_){ /*<>*/ return filter(p, xs, _u_);}, - function(_t_){ /*<>*/ return filter(_s_, xs, _t_);}] /*<>*/ ; + function(_E_){ /*<>*/ return filter(p, xs, _E_);}, + function(_D_){ /*<>*/ return filter(_C_, xs, _D_);}] /*<>*/ ; /*<>*/ } - function peel(xss){ - /*<>*/ return unzip - (function(_r_){ - /*<>*/ return filter_map(uncons, xss, _r_); - }) /*<>*/ ; - } function transpose(xss, param){ - var - match = /*<>*/ peel(xss), - tails = /*<>*/ match[2], - heads = match[1]; - /*<>*/ if(! is_empty(heads)) + function xys(_B_){ + /*<>*/ return filter_map(uncons, xss, _B_); + } + function tails(_A_){ /*<>*/ return map_snd(xys, _A_);} + function heads(_z_){ /*<>*/ return map_fst(xys, _z_);} + var _w_ = map_fst(xys, 0) ? 0 : 1; + /*<>*/ if(! _w_) /*<>*/ return [0, heads, - function(_q_){ - /*<>*/ return transpose(tails, _q_); + function(_y_){ + /*<>*/ return transpose(tails, _y_); }] /*<>*/ ; - /*<>*/ if(is_empty(tails)) /*<>*/ return 0; + var _x_ = /*<>*/ map_snd(xys, 0) ? 0 : 1; + /*<>*/ if(_x_) /*<>*/ return 0; /*<>*/ throw caml_maybe_attach_backtrace ([0, Assert_failure, _a_], 1); /*<>*/ } @@ -2407,27 +2408,33 @@ var xs$0 = match$0[2], x = match$0[1], - match$1 = /*<>*/ peel(remainders), - tails = /*<>*/ match$1[2], - heads = match$1[1], + xys$0 = + /*<>*/ function(_v_){ + return filter_map(uncons, remainders, _v_); + }, + tails$0 = + /*<>*/ function(_u_){return map_snd(xys$0, _u_);}, + heads$0 = + /*<>*/ function(_t_){return map_fst(xys$0, _t_);}, _l_ = - /*<>*/ function(_p_){ - /*<>*/ return [0, xs$0, tails]; + /*<>*/ function(_s_){ + /*<>*/ return [0, xs$0, tails$0]; }; /*<>*/ return [0, - function(_o_){ /*<>*/ return [0, x, heads];}, - function(_n_){ - /*<>*/ return _b_(_l_, xss$0, _n_); + function(_r_){ /*<>*/ return [0, x, heads$0];}, + function(_q_){ + /*<>*/ return _b_(_l_, xss$0, _q_); }] /*<>*/ ; } - var - match$2 = /*<>*/ peel(remainders), - tails$0 = /*<>*/ match$2[2], - heads$0 = match$2[1]; + function xys(_p_){ + /*<>*/ return filter_map(uncons, remainders, _p_); + } + function tails(_o_){ /*<>*/ return map_snd(xys, _o_);} + function heads(_n_){ /*<>*/ return map_fst(xys, _n_);} /*<>*/ return [0, - heads$0, + heads, function(_m_){ - /*<>*/ return _b_(tails$0, xss$0, _m_); + /*<>*/ return _b_(tails, xss$0, _m_); }] /*<>*/ ; /*<>*/ } function map_product(f, xs, ys){ @@ -10228,14 +10235,14 @@ /*<>*/ } function add_min_element(x, param){ /*<>*/ if(! param) - /*<>*/ return singleton(x) /*<>*/ ; + /*<>*/ return [0, 0, x, 0, 1]; var r = /*<>*/ param[3], v = param[2], l = param[1]; /*<>*/ return /*<>*/ bal ( /*<>*/ add_min_element(x, l), v, r) /*<>*/ ; } function add_max_element(x, param){ /*<>*/ if(! param) - /*<>*/ return singleton(x) /*<>*/ ; + /*<>*/ return [0, 0, x, 0, 1]; var r = /*<>*/ param[3], v = param[2], l = param[1]; /*<>*/ return /*<>*/ bal (l, v, /*<>*/ add_max_element(x, r)) /*<>*/ ; @@ -10905,26 +10912,20 @@ function of_list(l){ /*<>*/ if(! l) /*<>*/ return empty; var _n_ = /*<>*/ l[2], x0 = l[1]; - if(! _n_) - /*<>*/ return singleton(x0) /*<>*/ ; + if(! _n_) /*<>*/ return [0, 0, x0, 0, 1]; var _o_ = /*<>*/ _n_[2], x1 = _n_[1]; if(! _o_) - /*<>*/ return /*<>*/ add - (x1, /*<>*/ singleton(x0)) /*<>*/ ; + /*<>*/ return add(x1, [0, 0, x0, 0, 1]) /*<>*/ ; var _p_ = /*<>*/ _o_[2], x2 = _o_[1]; if(! _p_) - /*<>*/ return /*<>*/ add - (x2, - /*<>*/ add - (x1, /*<>*/ singleton(x0))) /*<>*/ ; + /*<>*/ return /*<>*/ add + (x2, /*<>*/ add(x1, [0, 0, x0, 0, 1])) /*<>*/ ; var _q_ = /*<>*/ _p_[2], x3 = _p_[1]; if(! _q_) - /*<>*/ return /*<>*/ add + /*<>*/ return /*<>*/ add (x3, /*<>*/ add - (x2, - /*<>*/ add - (x1, /*<>*/ singleton(x0)))) /*<>*/ ; + (x2, /*<>*/ add(x1, [0, 0, x0, 0, 1]))) /*<>*/ ; /*<>*/ if(_q_[2]){ var l$0 = /*<>*/ caml_call2(Stdlib_List[66], Ord[1], l), @@ -10991,14 +10992,12 @@ [1] /*<>*/ ; } var x4 = /*<>*/ _q_[1]; - /*<>*/ return /*<>*/ add + /*<>*/ return /*<>*/ add (x4, /*<>*/ add (x3, /*<>*/ add - (x2, - /*<>*/ add - (x1, /*<>*/ singleton(x0))))) /*<>*/ ; + (x2, /*<>*/ add(x1, [0, 0, x0, 0, 1])))) /*<>*/ ; } function add_seq(i, m){ /*<>*/ return caml_call3 @@ -11693,7 +11692,7 @@ /*<>*/ } function add_min_binding(k, x, param){ /*<>*/ if(! param) - /*<>*/ return singleton(k, x) /*<>*/ ; + /*<>*/ return [0, 0, k, x, 0, 1]; var r = /*<>*/ param[4], d = param[3], @@ -11704,7 +11703,7 @@ } function add_max_binding(k, x, param){ /*<>*/ if(! param) - /*<>*/ return singleton(k, x) /*<>*/ ; + /*<>*/ return [0, 0, k, x, 0, 1]; var r = /*<>*/ param[4], d = param[3], @@ -12284,7 +12283,7 @@ i) /*<>*/ ; } function of_seq(g){ - var s = /*<>*/ create(0); + var s = /*<>*/ [0, 0, 0]; /*<>*/ add_seq(s, g); /*<>*/ return s; /*<>*/ } @@ -12496,7 +12495,7 @@ i) /*<>*/ ; } function of_seq(g){ - var q = /*<>*/ create(0); + var q = /*<>*/ [0, 0, 0, 0]; /*<>*/ add_seq(q, g); /*<>*/ return q; /*<>*/ } @@ -13475,6 +13474,15 @@ /*<>*/ throw caml_maybe_attach_backtrace ([0, Assert_failure, _a_], 1); /*<>*/ } + function set_initial_keys(l){ + /*<>*/ return caml_call2 + (Stdlib_List[18], + function(param){ + var v = /*<>*/ param[2], k = param[1]; + /*<>*/ return set(k, v) /*<>*/ ; + }, + l) /*<>*/ ; + } function get_id(param){ var domain = /*<>*/ param[1]; /*<>*/ return domain; @@ -13557,13 +13565,7 @@ function body(param){ /*<>*/ try{ /*<>*/ create_dls(0); - /*<>*/ caml_call2 - (Stdlib_List[18], - function(param){ - var v = /*<>*/ param[2], k = param[1]; - /*<>*/ return set(k, v) /*<>*/ ; - }, - pk); + /*<>*/ set_initial_keys(pk); var res = /*<>*/ caml_call1(f, 0); } catch(exn$0){ @@ -13792,14 +13794,14 @@ var str_ind = /*<>*/ c >>> 3 | 0, mask = 1 << (c & 7), - _cm_ = + _cn_ = /*<>*/ runtime.caml_bytes_get (char_set, str_ind) | mask; /*<>*/ return /*<>*/ caml_bytes_set (char_set, str_ind, - /*<>*/ caml_call1(Stdlib[29], _cm_)) /*<>*/ ; + /*<>*/ caml_call1(Stdlib[29], _cn_)) /*<>*/ ; } function freeze_char_set(char_set){ /*<>*/ return caml_call1 @@ -13811,18 +13813,18 @@ i = /*<>*/ 0; for(;;){ var - _ck_ = + _cl_ = /*<>*/ caml_string_get(char_set, i) ^ 255; /*<>*/ /*<>*/ caml_bytes_set (char_set$0, i, - /*<>*/ caml_call1(Stdlib[29], _ck_)); - var _cl_ = /*<>*/ i + 1 | 0; + /*<>*/ caml_call1(Stdlib[29], _cl_)); + var _cm_ = /*<>*/ i + 1 | 0; if(31 === i) /*<>*/ return caml_call1 (Stdlib_Bytes[44], char_set$0) /*<>*/ ; - /*<>*/ i = _cl_; + /*<>*/ i = _cm_; } /*<>*/ } function is_in_char_set(char_set, c){ @@ -13891,11 +13893,11 @@ /*<>*/ if(prec_opt) var ndec = prec_opt[1], - _cj_ = /*<>*/ [0, ndec]; + _ck_ = /*<>*/ [0, ndec]; else - var _cj_ = /*<>*/ 0; + var _ck_ = /*<>*/ 0; /*<>*/ return [0, - [8, _a_, pad_of_pad_opt(pad_opt$5), _cj_, fmt]] /*<>*/ ; + [8, _a_, pad_of_pad_opt(pad_opt$5), _ck_, fmt]] /*<>*/ ; case 7: var pad_opt$6 = /*<>*/ ign[1]; /*<>*/ return [0, @@ -13926,11 +13928,6 @@ function default_float_precision(fconv){ /*<>*/ return 5 === fconv[2] ? 12 : -6 /*<>*/ ; } - function buffer_create(init_size){ - /*<>*/ return [0, - 0, - caml_create_bytes(init_size)] /*<>*/ ; - /*<>*/ } function buffer_check_size(buf, overhead){ var len = @@ -14010,6 +14007,158 @@ default: /*<>*/ return 70; } /*<>*/ } + function bprint_char_set(buf, char_set){ + function print_char(buf, i){ + var c = /*<>*/ caml_call1(Stdlib[29], i); + /*<>*/ return 37 === c + ? ( /*<>*/ buffer_add_char + (buf, 37), + /*<>*/ buffer_add_char(buf, 37)) + : 64 + === c + ? ( /*<>*/ buffer_add_char + (buf, 37), + /*<>*/ buffer_add_char + (buf, 64)) + : /*<>*/ buffer_add_char(buf, c) /*<>*/ ; + } + /*<>*/ buffer_add_char(buf, 91); + var + set = + /*<>*/ is_in_char_set(char_set, 0) + ? ( /*<>*/ buffer_add_char + (buf, 94), + /*<>*/ rev_char_set(char_set)) + : char_set; + function is_alone(c){ + var + after = + /*<>*/ caml_call1 + (Stdlib_Char[1], c + 1 | 0), + before = + /*<>*/ caml_call1 + (Stdlib_Char[1], c - 1 | 0), + _cg_ = /*<>*/ is_in_char_set(set, c); + /*<>*/ if(_cg_) + var + _ch_ = + /*<>*/ is_in_char_set(set, before), + _ci_ = + /*<>*/ _ch_ + ? /*<>*/ is_in_char_set(set, after) + : _ch_, + _cj_ = /*<>*/ 1 - _ci_; + else + var _cj_ = /*<>*/ _cg_; + return _cj_; + /*<>*/ } + /*<>*/ if(is_alone(93)) + /*<>*/ buffer_add_char(buf, 93); + var i = /*<>*/ 1; + for(;;){ + a: + if(i < 256){ + /*<>*/ if + (! + /*<>*/ is_in_char_set + (set, + /*<>*/ caml_call1(Stdlib[29], i))){ + var i$0 = /*<>*/ i + 1 | 0; + i = i$0; + continue; + } + var + switcher = + /*<>*/ caml_call1(Stdlib[29], i) - 45 + | 0; + /*<>*/ if(48 < switcher >>> 0){ + if(210 <= switcher){ + /*<>*/ print_char(buf, 255); + break a; + } + } + else if(46 < switcher - 1 >>> 0){ + var i$2 = /*<>*/ i + 1 | 0; + i = i$2; + continue; + } + var i$1 = /*<>*/ i + 1 | 0; + /*<>*/ if + (! + /*<>*/ is_in_char_set + (set, + /*<>*/ caml_call1(Stdlib[29], i$1))){ + /*<>*/ print_char(buf, i$1 - 1 | 0); + var i$6 = /*<>*/ i$1 + 1 | 0; + i = i$6; + continue; + } + var + switcher$0 = + /*<>*/ caml_call1(Stdlib[29], i$1) + - 45 + | 0; + /*<>*/ if(48 < switcher$0 >>> 0){ + if(210 <= switcher$0){ + /*<>*/ print_char(buf, 254); + /*<>*/ print_char(buf, 255); + break a; + } + } + else if + (46 < switcher$0 - 1 >>> 0 + && + ! + /*<>*/ is_in_char_set + (set, + /*<>*/ caml_call1 + (Stdlib[29], i$1 + 1 | 0))){ + /*<>*/ print_char(buf, i$1 - 1 | 0); + var i$5 = /*<>*/ i$1 + 1 | 0; + i = i$5; + continue; + } + /*<>*/ if + (! + /*<>*/ is_in_char_set + (set, + /*<>*/ caml_call1 + (Stdlib[29], i$1 + 1 | 0))){ + /*<>*/ print_char(buf, i$1 - 1 | 0); + /*<>*/ print_char(buf, i$1); + var i$4 = /*<>*/ i$1 + 2 | 0; + i = i$4; + continue; + } + var + j = /*<>*/ i$1 + 2 | 0, + i$3 = i$1 - 1 | 0, + j$0 = j; + for(;;){ + /*<>*/ if(256 === j$0) break; + /*<>*/ if + (! + /*<>*/ is_in_char_set + (set, + /*<>*/ caml_call1(Stdlib[29], j$0))) + break; + var j$1 = /*<>*/ j$0 + 1 | 0; + j$0 = j$1; + } + /*<>*/ print_char(buf, i$3); + /*<>*/ print_char(buf, 45); + /*<>*/ print_char(buf, j$0 - 1 | 0); + /*<>*/ if(j$0 < 256){ + var i$7 = /*<>*/ j$0 + 1 | 0; + i = i$7; + continue; + } + } + /*<>*/ if(is_alone(45)) + /*<>*/ buffer_add_char(buf, 45); + /*<>*/ return buffer_add_char(buf, 93) /*<>*/ ; + } + } function bprint_padty(buf, padty){ /*<>*/ switch(padty){ case 0: @@ -14127,11 +14276,11 @@ default: var c = /*<>*/ formatting_lit[1], - _ci_ = + _cf_ = /*<>*/ caml_call2 (Stdlib_String[1], 1, c); /*<>*/ return caml_call2 - (Stdlib[28], cst$7, _ci_); + (Stdlib[28], cst$7, _cf_); } } function bprint_char_literal(buf, chr){ @@ -14142,17 +14291,17 @@ } function bprint_string_literal(buf, str){ var - _cg_ = + _cd_ = /*<>*/ caml_ml_string_length(str) - 1 | 0, - _cf_ = 0; - if(_cg_ >= 0){ - var i = _cf_; + _cc_ = 0; + if(_cd_ >= 0){ + var i = _cc_; for(;;){ /*<>*/ /*<>*/ bprint_char_literal (buf, /*<>*/ caml_string_get(str, i)); - var _ch_ = /*<>*/ i + 1 | 0; - if(_cg_ === i) break; - i = _ch_; + var _ce_ = /*<>*/ i + 1 | 0; + if(_cd_ === i) break; + i = _ce_; } } /*<>*/ } @@ -14255,7 +14404,8 @@ | 0 /*<>*/ ; } function string_of_fmt(fmt){ - var buf = /*<>*/ buffer_create(16); + var + buf = /*<>*/ [0, 0, caml_create_bytes(16)]; function fmtiter(fmt$1, ign_flag$0){ var fmt = /*<>*/ fmt$1, @@ -14499,178 +14649,7 @@ /*<>*/ bprint_ignored_flag (buf, ign_flag); /*<>*/ bprint_pad_opt(buf, width_opt); - var - print_char = - /*<>*/ function(buf, i){ - var - c = - /*<>*/ caml_call1 - (Stdlib[29], i); - /*<>*/ return 37 === c - ? ( /*<>*/ buffer_add_char - (buf, 37), - /*<>*/ buffer_add_char - (buf, 37)) - : 64 - === c - ? ( /*<>*/ buffer_add_char - (buf, 37), - /*<>*/ buffer_add_char - (buf, 64)) - : /*<>*/ buffer_add_char - (buf, c) /*<>*/ ; - }; - /*<>*/ buffer_add_char(buf, 91); - var - set = - /*<>*/ is_in_char_set(char_set, 0) - ? ( /*<>*/ buffer_add_char - (buf, 94), - /*<>*/ rev_char_set(char_set)) - : char_set; - let set$0 = /*<>*/ set; - var - is_alone = - function(c){ - var - after = - /*<>*/ caml_call1 - (Stdlib_Char[1], c + 1 | 0), - before = - /*<>*/ caml_call1 - (Stdlib_Char[1], c - 1 | 0), - _cb_ = - /*<>*/ is_in_char_set(set$0, c); - /*<>*/ if(_cb_) - var - _cc_ = - /*<>*/ is_in_char_set - (set$0, before), - _cd_ = - /*<>*/ _cc_ - ? /*<>*/ is_in_char_set - (set$0, after) - : _cc_, - _ce_ = /*<>*/ 1 - _cd_; - else - var _ce_ = /*<>*/ _cb_; - return _ce_; - /*<>*/ }; - /*<>*/ if(is_alone(93)) - /*<>*/ buffer_add_char(buf, 93); - a: - { - b: - { - var i = /*<>*/ 1; - for(;;){ - /*<>*/ if(i >= 256) break a; - /*<>*/ if - ( /*<>*/ is_in_char_set - (set, - /*<>*/ caml_call1 - (Stdlib[29], i))){ - var - switcher = - /*<>*/ caml_call1 - (Stdlib[29], i) - - 45 - | 0; - /*<>*/ if(48 < switcher >>> 0){ - if(210 <= switcher) break; - } - else if(46 < switcher - 1 >>> 0){ - var i$2 = /*<>*/ i + 1 | 0; - i = i$2; - continue; - } - var i$1 = /*<>*/ i + 1 | 0; - /*<>*/ if - ( /*<>*/ is_in_char_set - (set, - /*<>*/ caml_call1 - (Stdlib[29], i$1))){ - var - switcher$0 = - /*<>*/ caml_call1 - (Stdlib[29], i$1) - - 45 - | 0; - /*<>*/ if(48 < switcher$0 >>> 0){ - if(210 <= switcher$0) break b; - } - else if - (46 < switcher$0 - 1 >>> 0 - && - ! - /*<>*/ is_in_char_set - (set, - /*<>*/ caml_call1 - (Stdlib[29], i$1 + 1 | 0))){ - /*<>*/ print_char - (buf, i$1 - 1 | 0); - var i$5 = /*<>*/ i$1 + 1 | 0; - i = i$5; - continue; - } - /*<>*/ if - ( /*<>*/ is_in_char_set - (set, - /*<>*/ caml_call1 - (Stdlib[29], i$1 + 1 | 0))){ - var - j = /*<>*/ i$1 + 2 | 0, - i$3 = i$1 - 1 | 0, - j$0 = j; - for(;;){ - /*<>*/ if(256 === j$0) break; - /*<>*/ if - (! - /*<>*/ is_in_char_set - (set, - /*<>*/ caml_call1 - (Stdlib[29], j$0))) - break; - var j$1 = /*<>*/ j$0 + 1 | 0; - j$0 = j$1; - } - /*<>*/ print_char(buf, i$3); - /*<>*/ print_char(buf, 45); - /*<>*/ print_char - (buf, j$0 - 1 | 0); - /*<>*/ if(j$0 >= 256) break a; - var i$7 = /*<>*/ j$0 + 1 | 0; - i = i$7; - } - else{ - /*<>*/ print_char - (buf, i$1 - 1 | 0); - /*<>*/ print_char(buf, i$1); - var i$4 = /*<>*/ i$1 + 2 | 0; - i = i$4; - } - } - else{ - /*<>*/ print_char - (buf, i$1 - 1 | 0); - var i$6 = /*<>*/ i$1 + 1 | 0; - i = i$6; - } - } - else{ - var i$0 = /*<>*/ i + 1 | 0; - i = i$0; - } - } - /*<>*/ print_char(buf, 255); - break a; - } - /*<>*/ print_char(buf, 254); - /*<>*/ print_char(buf, 255); - } - /*<>*/ if(is_alone(45)) - /*<>*/ buffer_add_char(buf, 45); - /*<>*/ buffer_add_char(buf, 93); + /*<>*/ bprint_char_set(buf, char_set); /*<>*/ fmt = rest$19; ign_flag = 0; break; @@ -14683,12 +14662,12 @@ (buf, ign_flag); /*<>*/ switch(counter){ case 0: - var _b9_ = /*<>*/ 108; break; + var _b__ = /*<>*/ 108; break; case 1: - var _b9_ = /*<>*/ 110; break; - default: var _b9_ = /*<>*/ 78; + var _b__ = /*<>*/ 110; break; + default: var _b__ = /*<>*/ 78; } - /*<>*/ buffer_add_char(buf, _b9_); + /*<>*/ buffer_add_char(buf, _b__); /*<>*/ fmt = rest$20; ign_flag = 0; break; @@ -14717,19 +14696,19 @@ var rest$23 = /*<>*/ fmt[3], arity = fmt[1], - _b$_ = + _ca_ = /*<>*/ int_of_custom_arity(arity), - _b__ = /*<>*/ 1; - if(_b$_ >= 1){ - var i$8 = _b__; + _b$_ = /*<>*/ 1; + if(_ca_ >= 1){ + var i = _b$_; for(;;){ /*<>*/ buffer_add_char(buf, 37); /*<>*/ bprint_ignored_flag (buf, ign_flag); /*<>*/ buffer_add_char(buf, 63); - var _ca_ = /*<>*/ i$8 + 1 | 0; - if(_b$_ === i$8) break; - i$8 = _ca_; + var _cb_ = /*<>*/ i + 1 | 0; + if(_ca_ === i) break; + i = _cb_; } } /*<>*/ fmt = rest$23; @@ -15243,12 +15222,12 @@ var rest2$7 = ty2[2], ty2$0 = ty2[1], - _b8_ = + _b9_ = /*<>*/ trans (rest1$7, rest2$7); /*<>*/ return [8, trans(ty1$0, ty2$0), - _b8_] /*<>*/ ; + _b9_] /*<>*/ ; case 10: break a; case 11: @@ -15559,17 +15538,17 @@ var rest$13 = /*<>*/ fmtty$0[2], formatting_gen = fmtty$0[1], - _b5_ = /*<>*/ fmtty_of_fmt(rest$13); + _b6_ = /*<>*/ fmtty_of_fmt(rest$13); /*<>*/ if(0 === formatting_gen[0]) var fmt = formatting_gen[1][1], - _b6_ = /*<>*/ fmtty_of_fmt(fmt); + _b7_ = /*<>*/ fmtty_of_fmt(fmt); else var fmt$0 = /*<>*/ formatting_gen[1][1], - _b6_ = /*<>*/ fmtty_of_fmt(fmt$0); + _b7_ = /*<>*/ fmtty_of_fmt(fmt$0); /*<>*/ return caml_call2 - (CamlinternalFormatBasics[1], _b6_, _b5_) /*<>*/ ; + (CamlinternalFormatBasics[1], _b7_, _b6_) /*<>*/ ; case 19: var rest$14 = /*<>*/ fmtty$0[1]; /*<>*/ return [13, @@ -15600,9 +15579,9 @@ if(9 === ign[0]){ var fmtty$6 = ign[2], - _b7_ = /*<>*/ fmtty_of_fmt(fmtty$5); + _b8_ = /*<>*/ fmtty_of_fmt(fmtty$5); /*<>*/ return caml_call2 - (CamlinternalFormatBasics[1], fmtty$6, _b7_) /*<>*/ ; + (CamlinternalFormatBasics[1], fmtty$6, _b8_) /*<>*/ ; } /*<>*/ fmtty$0 = fmtty$5; } @@ -15899,11 +15878,11 @@ /*<>*/ } function type_format(fmt, fmtty){ var - _b4_ = /*<>*/ type_format_gen(fmt, fmtty); - /*<>*/ if(typeof _b4_[2] !== "number") + _b5_ = /*<>*/ type_format_gen(fmt, fmtty); + /*<>*/ if(typeof _b5_[2] !== "number") /*<>*/ throw caml_maybe_attach_backtrace (Type_mismatch, 1); - var fmt$0 = /*<>*/ _b4_[1]; + var fmt$0 = /*<>*/ _b5_[1]; /*<>*/ return fmt$0; /*<>*/ } function type_format_gen(fmt, fmtty0){ @@ -16199,7 +16178,7 @@ fmt_rest$13 = fmt[3], sub_fmtty$1 = fmt[2], pad_opt$0 = fmt[1], - _b2_ = + _b3_ = /*<>*/ [0, caml_call1(CamlinternalFormatBasics[2], sub_fmtty1)]; /*<>*/ if @@ -16207,7 +16186,7 @@ ([0, /*<>*/ caml_call1 (CamlinternalFormatBasics[2], sub_fmtty$1)], - _b2_)) + _b3_)) /*<>*/ throw caml_maybe_attach_backtrace (Type_mismatch, 1); var @@ -16396,13 +16375,13 @@ var sub_fmtty$3 = /*<>*/ ign[2], pad_opt$2 = ign[1], - _b3_ = + _b4_ = /*<>*/ type_ignored_format_substituti (sub_fmtty$3, rest, fmtty0), - match$43 = /*<>*/ _b3_[2], + match$43 = /*<>*/ _b4_[2], fmtty$21 = match$43[2], fmt$22 = match$43[1], - sub_fmtty$4 = _b3_[1]; + sub_fmtty$4 = _b4_[1]; /*<>*/ return [0, [23, [9, pad_opt$2, sub_fmtty$4], fmt$22], fmtty$21]; @@ -16620,7 +16599,7 @@ sub_fmtty_rest$17 = sub_fmtty[3], sub2_fmtty$2 = sub_fmtty[2], sub1_fmtty$0 = sub_fmtty[1], - _b0_ = + _b1_ = /*<>*/ [0, caml_call1(CamlinternalFormatBasics[2], sub1_fmtty)]; /*<>*/ if @@ -16628,11 +16607,11 @@ ([0, /*<>*/ caml_call1 (CamlinternalFormatBasics[2], sub1_fmtty$0)], - _b0_)) + _b1_)) /*<>*/ throw caml_maybe_attach_backtrace (Type_mismatch, 1); var - _b1_ = + _b2_ = /*<>*/ [0, caml_call1(CamlinternalFormatBasics[2], sub2_fmtty$1)]; /*<>*/ if @@ -16640,7 +16619,7 @@ ([0, /*<>*/ caml_call1 (CamlinternalFormatBasics[2], sub2_fmtty$2)], - _b1_)) + _b2_)) /*<>*/ throw caml_maybe_attach_backtrace (Type_mismatch, 1); var @@ -16737,11 +16716,11 @@ (Type_mismatch, 1); /*<>*/ } function recast(fmt, fmtty){ - var _bZ_ = /*<>*/ symm(fmtty); + var _b0_ = /*<>*/ symm(fmtty); /*<>*/ return /*<>*/ type_format (fmt, /*<>*/ caml_call1 - (CamlinternalFormatBasics[2], _bZ_)) /*<>*/ ; + (CamlinternalFormatBasics[2], _b0_)) /*<>*/ ; } function fix_padding(padty, width, str){ var @@ -16752,10 +16731,10 @@ /*<>*/ if(width$0 <= len) /*<>*/ return str; var - _bY_ = /*<>*/ 2 === padty$0 ? 48 : 32, + _bZ_ = /*<>*/ 2 === padty$0 ? 48 : 32, res = /*<>*/ caml_call2 - (Stdlib_Bytes[1], width$0, _bY_); + (Stdlib_Bytes[1], width$0, _bZ_); /*<>*/ switch(padty$0){ case 0: /*<>*/ caml_call5 @@ -16926,7 +16905,7 @@ prec$0 = /*<>*/ caml_call1(Stdlib[18], prec), symb = /*<>*/ char_of_fconv(_r_, fconv), - buf = /*<>*/ buffer_create(16); + buf = /*<>*/ [0, 0, caml_create_bytes(16)]; /*<>*/ buffer_add_char(buf, 37); /*<>*/ bprint_fconv_flag(buf, fconv); /*<>*/ buffer_add_char(buf, 46); @@ -16942,18 +16921,18 @@ /*<>*/ return s; var n = /*<>*/ [0, 0], - _bT_ = + _bU_ = /*<>*/ caml_ml_string_length(s) - 1 | 0, - _bS_ = 0; - if(_bT_ >= 0){ - var i$0 = _bS_; + _bT_ = 0; + if(_bU_ >= 0){ + var i$0 = _bT_; for(;;){ /*<>*/ if (9 >= caml_string_unsafe_get(s, i$0) - 48 >>> 0) /*<>*/ n[1]++; - var _bX_ = /*<>*/ i$0 + 1 | 0; - if(_bT_ === i$0) break; - i$0 = _bX_; + var _bY_ = /*<>*/ i$0 + 1 | 0; + if(_bU_ === i$0) break; + i$0 = _bY_; } } var @@ -16972,11 +16951,11 @@ left = /*<>*/ [0, ((digits - 1 | 0) % 3 | 0) + 1 | 0], - _bV_ = + _bW_ = /*<>*/ caml_ml_string_length(s) - 1 | 0, - _bU_ = 0; - if(_bV_ >= 0){ - var i = _bU_; + _bV_ = 0; + if(_bW_ >= 0){ + var i = _bV_; for(;;){ var c = /*<>*/ caml_string_unsafe_get(s, i); @@ -16990,9 +16969,9 @@ /*<>*/ left[1]--; /*<>*/ put(c); } - var _bW_ = /*<>*/ i + 1 | 0; - if(_bV_ === i) break; - i = _bW_; + var _bX_ = /*<>*/ i + 1 | 0; + if(_bW_ === i) break; + i = _bX_; } } /*<>*/ return caml_call1 @@ -17001,139 +16980,139 @@ function convert_int(iconv, n){ /*<>*/ switch(iconv){ case 1: - var _bR_ = cst_d$0; break; + var _bS_ = cst_d$0; break; case 2: - var _bR_ = cst_d$1; break; + var _bS_ = cst_d$1; break; case 4: - var _bR_ = cst_i$1; break; + var _bS_ = cst_i$1; break; case 5: - var _bR_ = cst_i$2; break; + var _bS_ = cst_i$2; break; case 6: - var _bR_ = cst_x; break; + var _bS_ = cst_x; break; case 7: - var _bR_ = cst_x$0; break; + var _bS_ = cst_x$0; break; case 8: - var _bR_ = cst_X; break; + var _bS_ = cst_X; break; case 9: - var _bR_ = cst_X$0; break; + var _bS_ = cst_X$0; break; case 10: - var _bR_ = cst_o; break; + var _bS_ = cst_o; break; case 11: - var _bR_ = cst_o$0; break; + var _bS_ = cst_o$0; break; case 0: case 13: - var _bR_ = cst_d; break; + var _bS_ = cst_d; break; case 3: case 14: - var _bR_ = cst_i$0; break; - default: var _bR_ = cst_u; + var _bS_ = cst_i$0; break; + default: var _bS_ = cst_u; } /*<>*/ return /*<>*/ transform_int_alt (iconv, - /*<>*/ caml_format_int(_bR_, n)) /*<>*/ ; + /*<>*/ caml_format_int(_bS_, n)) /*<>*/ ; } function convert_int32(iconv, n){ /*<>*/ switch(iconv){ case 1: - var _bQ_ = cst_ld$0; break; + var _bR_ = cst_ld$0; break; case 2: - var _bQ_ = cst_ld$1; break; + var _bR_ = cst_ld$1; break; case 4: - var _bQ_ = cst_li$1; break; + var _bR_ = cst_li$1; break; case 5: - var _bQ_ = cst_li$2; break; + var _bR_ = cst_li$2; break; case 6: - var _bQ_ = cst_lx; break; + var _bR_ = cst_lx; break; case 7: - var _bQ_ = cst_lx$0; break; + var _bR_ = cst_lx$0; break; case 8: - var _bQ_ = cst_lX; break; + var _bR_ = cst_lX; break; case 9: - var _bQ_ = cst_lX$0; break; + var _bR_ = cst_lX$0; break; case 10: - var _bQ_ = cst_lo; break; + var _bR_ = cst_lo; break; case 11: - var _bQ_ = cst_lo$0; break; + var _bR_ = cst_lo$0; break; case 0: case 13: - var _bQ_ = cst_ld; break; + var _bR_ = cst_ld; break; case 3: case 14: - var _bQ_ = cst_li$0; break; - default: var _bQ_ = cst_lu; + var _bR_ = cst_li$0; break; + default: var _bR_ = cst_lu; } /*<>*/ return /*<>*/ transform_int_alt (iconv, - /*<>*/ caml_format_int(_bQ_, n)) /*<>*/ ; + /*<>*/ caml_format_int(_bR_, n)) /*<>*/ ; } function convert_nativeint(iconv, n){ /*<>*/ switch(iconv){ case 1: - var _bP_ = cst_nd$0; break; + var _bQ_ = cst_nd$0; break; case 2: - var _bP_ = cst_nd$1; break; + var _bQ_ = cst_nd$1; break; case 4: - var _bP_ = cst_ni$1; break; + var _bQ_ = cst_ni$1; break; case 5: - var _bP_ = cst_ni$2; break; + var _bQ_ = cst_ni$2; break; case 6: - var _bP_ = cst_nx; break; + var _bQ_ = cst_nx; break; case 7: - var _bP_ = cst_nx$0; break; + var _bQ_ = cst_nx$0; break; case 8: - var _bP_ = cst_nX; break; + var _bQ_ = cst_nX; break; case 9: - var _bP_ = cst_nX$0; break; + var _bQ_ = cst_nX$0; break; case 10: - var _bP_ = cst_no; break; + var _bQ_ = cst_no; break; case 11: - var _bP_ = cst_no$0; break; + var _bQ_ = cst_no$0; break; case 0: case 13: - var _bP_ = cst_nd; break; + var _bQ_ = cst_nd; break; case 3: case 14: - var _bP_ = cst_ni$0; break; - default: var _bP_ = cst_nu; + var _bQ_ = cst_ni$0; break; + default: var _bQ_ = cst_nu; } /*<>*/ return /*<>*/ transform_int_alt (iconv, - /*<>*/ caml_format_int(_bP_, n)) /*<>*/ ; + /*<>*/ caml_format_int(_bQ_, n)) /*<>*/ ; } function convert_int64(iconv, n){ /*<>*/ switch(iconv){ case 1: - var _bO_ = cst_Ld$0; break; + var _bP_ = cst_Ld$0; break; case 2: - var _bO_ = cst_Ld$1; break; + var _bP_ = cst_Ld$1; break; case 4: - var _bO_ = cst_Li$1; break; + var _bP_ = cst_Li$1; break; case 5: - var _bO_ = cst_Li$2; break; + var _bP_ = cst_Li$2; break; case 6: - var _bO_ = cst_Lx; break; + var _bP_ = cst_Lx; break; case 7: - var _bO_ = cst_Lx$0; break; + var _bP_ = cst_Lx$0; break; case 8: - var _bO_ = cst_LX; break; + var _bP_ = cst_LX; break; case 9: - var _bO_ = cst_LX$0; break; + var _bP_ = cst_LX$0; break; case 10: - var _bO_ = cst_Lo; break; + var _bP_ = cst_Lo; break; case 11: - var _bO_ = cst_Lo$0; break; + var _bP_ = cst_Lo$0; break; case 0: case 13: - var _bO_ = cst_Ld; break; + var _bP_ = cst_Ld; break; case 3: case 14: - var _bO_ = cst_Li$0; break; - default: var _bO_ = cst_Lu; + var _bP_ = cst_Li$0; break; + default: var _bP_ = cst_Lu; } /*<>*/ return /*<>*/ transform_int_alt (iconv, /*<>*/ runtime.caml_int64_format - (_bO_, n)) /*<>*/ ; + (_bP_, n)) /*<>*/ ; } function convert_float(fconv, prec, x){ function hex(param){ @@ -17170,39 +17149,39 @@ { /*<>*/ if(i !== len){ var - _bK_ = + _bL_ = /*<>*/ caml_string_get(str, i) - 46 | 0; b: { - /*<>*/ if(23 < _bK_ >>> 0){ - if(55 !== _bK_) break b; + /*<>*/ if(23 < _bL_ >>> 0){ + if(55 !== _bL_) break b; } - else if(21 >= _bK_ - 1 >>> 0) break b; - var _bL_ = /*<>*/ 1; + else if(21 >= _bL_ - 1 >>> 0) break b; + var _bM_ = /*<>*/ 1; break a; } var i$0 = /*<>*/ i + 1 | 0; i = i$0; continue; } - var _bL_ = /*<>*/ 0; + var _bM_ = /*<>*/ 0; } var - _bM_ = - /*<>*/ _bL_ + _bN_ = + /*<>*/ _bM_ ? str : /*<>*/ caml_call2 (Stdlib[28], str, cst$17); - /*<>*/ return caml_special_val(_bM_) /*<>*/ ; + /*<>*/ return caml_special_val(_bN_) /*<>*/ ; } case 6: /*<>*/ return hex(0) /*<>*/ ; case 7: - var _bN_ = /*<>*/ hex(0); + var _bO_ = /*<>*/ hex(0); /*<>*/ return caml_call1 - (Stdlib_String[26], _bN_) /*<>*/ ; + (Stdlib_String[26], _bO_) /*<>*/ ; case 8: /*<>*/ return /*<>*/ caml_special_val ( /*<>*/ hex(0)) /*<>*/ ; @@ -17214,7 +17193,8 @@ } } function string_of_fmtty(fmtty){ - var buf = /*<>*/ buffer_create(16); + var + buf = /*<>*/ [0, 0, caml_create_bytes(16)]; /*<>*/ bprint_fmtty(buf, fmtty); /*<>*/ return buffer_contents(buf) /*<>*/ ; } @@ -17340,9 +17320,9 @@ fmt = rest$16; break; case 18: - var _bH_ = /*<>*/ fmt[1]; - if(0 === _bH_[0]){ - var rest$17 = fmt[2], fmt$0 = _bH_[1][1]; + var _bI_ = /*<>*/ fmt[1]; + if(0 === _bI_[0]){ + var rest$17 = fmt[2], fmt$0 = _bI_[1][1]; let acc$0 = /*<>*/ acc, k$1 = k, @@ -17360,7 +17340,7 @@ else{ var rest$18 = /*<>*/ fmt[2], - fmt$1 = _bH_[1][1]; + fmt$1 = _bI_[1][1]; let acc$0 = /*<>*/ acc, k$0 = k, @@ -17401,16 +17381,16 @@ rest$23 = /*<>*/ fmt[3], f = fmt[2], arity = fmt[1], - _bI_ = + _bJ_ = /*<>*/ caml_call1(f, 0); /*<>*/ if(counter >= 50) return caml_trampoline_return - (make_custom$0, [0, k, acc, rest$23, arity, _bI_]) /*<>*/ ; + (make_custom$0, [0, k, acc, rest$23, arity, _bJ_]) /*<>*/ ; var counter$0 = /*<>*/ counter + 1 | 0; return make_custom$0 - (counter$0, k, acc, rest$23, arity, _bI_) /*<>*/ ; + (counter$0, k, acc, rest$23, arity, _bJ_) /*<>*/ ; } } var rest$21 = /*<>*/ fmt[1]; @@ -17463,12 +17443,12 @@ /*<>*/ return function(param){ var fmt = param[1], - _bJ_ = /*<>*/ recast(fmt, fmtty); + _bK_ = /*<>*/ recast(fmt, fmtty); /*<>*/ return /*<>*/ make_printf (k, acc, /*<>*/ caml_call2 - (CamlinternalFormatBasics[3], _bJ_, rest$13)) /*<>*/ ;} /*<>*/ ; + (CamlinternalFormatBasics[3], _bK_, rest$13)) /*<>*/ ;} /*<>*/ ; } var rest$12 = /*<>*/ fmt[3], @@ -17808,7 +17788,7 @@ fmt) /*<>*/ ;} /*<>*/ ; case 10: var rest$9 = /*<>*/ fmtty[1]; - /*<>*/ return function(_bG_, param){ + /*<>*/ return function(_bH_, param){ /*<>*/ return make_from_fmtty (k, acc, rest$9, fmt) /*<>*/ ;} /*<>*/ ; case 11: @@ -17840,14 +17820,14 @@ } function make_invalid_arg(counter, k, acc, fmt){ var - _bF_ = + _bG_ = /*<>*/ [8, acc, cst_Printf_bad_conversion$0]; if(counter >= 50) - return caml_trampoline_return(make_printf$0, [0, k, _bF_, fmt]) /*<>*/ ; + return caml_trampoline_return(make_printf$0, [0, k, _bG_, fmt]) /*<>*/ ; var counter$0 = /*<>*/ counter + 1 | 0; - return make_printf$0(counter$0, k, _bF_, fmt) /*<>*/ ; + return make_printf$0(counter$0, k, _bG_, fmt) /*<>*/ ; } function make_padding(k, acc, fmt, pad, trans){ /*<>*/ if(typeof pad === "number") @@ -18014,11 +17994,11 @@ arity$0, /*<>*/ caml_call1(f, x)) /*<>*/ ;} /*<>*/ ; } - var _bE_ = /*<>*/ [4, acc, f]; + var _bF_ = /*<>*/ [4, acc, f]; if(counter >= 50) - return caml_trampoline_return(make_printf$0, [0, k, _bE_, rest]) /*<>*/ ; + return caml_trampoline_return(make_printf$0, [0, k, _bF_, rest]) /*<>*/ ; var counter$0 = /*<>*/ counter + 1 | 0; - return make_printf$0(counter$0, k, _bE_, rest) /*<>*/ ; + return make_printf$0(counter$0, k, _bF_, rest) /*<>*/ ; } function make_custom(k, acc, rest, arity, f){ /*<>*/ return /*<>*/ caml_trampoline @@ -18126,9 +18106,9 @@ /*<>*/ fmt = rest$22; break; case 18: - var _bh_ = /*<>*/ fmt[1]; - if(0 === _bh_[0]){ - var rest$23 = fmt[2], fmt$0 = _bh_[1][1]; + var _bi_ = /*<>*/ fmt[1]; + if(0 === _bi_[0]){ + var rest$23 = fmt[2], fmt$0 = _bi_[1][1]; let k$1 = /*<>*/ k, rest = rest$23; @@ -18144,7 +18124,7 @@ else{ var rest$24 = /*<>*/ fmt[2], - fmt$1 = _bh_[1][1]; + fmt$1 = _bi_[1][1]; let k$0 = /*<>*/ k, rest = rest$24; @@ -18199,7 +18179,7 @@ x$19 = /*<>*/ make_iprintf (k, o, rest$27); - /*<>*/ return function(_bD_){ + /*<>*/ return function(_bE_){ /*<>*/ return x$19;} /*<>*/ ; } var @@ -18207,7 +18187,7 @@ x$18 = /*<>*/ make_iprintf (k, o, rest$26); - /*<>*/ return function(_bC_){ + /*<>*/ return function(_bD_){ /*<>*/ return x$18;} /*<>*/ ; } var @@ -18215,7 +18195,7 @@ x$17 = /*<>*/ make_iprintf (k, o, rest$25); - /*<>*/ return function(_bB_){ + /*<>*/ return function(_bC_){ /*<>*/ return x$17;} /*<>*/ ; } var @@ -18223,7 +18203,7 @@ x$16 = /*<>*/ make_iprintf (k, o, rest$21); - /*<>*/ return function(_bA_){ + /*<>*/ return function(_bB_){ /*<>*/ return x$16;} /*<>*/ ; } var @@ -18232,10 +18212,10 @@ /*<>*/ make_iprintf (k, o, rest$20), x$15 = - /*<>*/ function(_bz_){ + /*<>*/ function(_bA_){ /*<>*/ return x$14; }; - /*<>*/ return function(_by_){ + /*<>*/ return function(_bz_){ /*<>*/ return x$15;} /*<>*/ ; } var @@ -18244,35 +18224,35 @@ /*<>*/ return function(param){ var fmt = param[1], - _bx_ = /*<>*/ recast(fmt, fmtty); + _by_ = /*<>*/ recast(fmt, fmtty); /*<>*/ return /*<>*/ make_iprintf (k, o, /*<>*/ caml_call2 - (CamlinternalFormatBasics[3], _bx_, rest$19)) /*<>*/ ;} /*<>*/ ; + (CamlinternalFormatBasics[3], _by_, rest$19)) /*<>*/ ;} /*<>*/ ; } var rest$18 = /*<>*/ fmt[3], x$13 = /*<>*/ make_iprintf(k, o, rest$18); - /*<>*/ return function(_bw_){ + /*<>*/ return function(_bx_){ /*<>*/ return x$13;} /*<>*/ ; } - var _bg_ = /*<>*/ fmt[1]; - if(typeof _bg_ === "number"){ + var _bh_ = /*<>*/ fmt[1]; + if(typeof _bh_ === "number"){ var rest$12 = fmt[2], x$9 = /*<>*/ make_iprintf(k, o, rest$12); - /*<>*/ return function(_bv_){ + /*<>*/ return function(_bw_){ /*<>*/ return x$9;} /*<>*/ ; } - /*<>*/ if(0 === _bg_[0]){ + /*<>*/ if(0 === _bh_[0]){ var rest$13 = fmt[2], x$10 = /*<>*/ make_iprintf(k, o, rest$13); - /*<>*/ return function(_bu_){ + /*<>*/ return function(_bv_){ /*<>*/ return x$10;} /*<>*/ ; } var @@ -18280,27 +18260,27 @@ x$11 = /*<>*/ make_iprintf(k, o, rest$14), x$12 = - /*<>*/ function(_bt_){ + /*<>*/ function(_bu_){ /*<>*/ return x$11; }; - /*<>*/ return function(_bs_){ + /*<>*/ return function(_bt_){ /*<>*/ return x$12;} /*<>*/ ; } - var _bf_ = /*<>*/ fmt[1]; - if(typeof _bf_ === "number"){ + var _bg_ = /*<>*/ fmt[1]; + if(typeof _bg_ === "number"){ var rest$4 = fmt[2], x$5 = /*<>*/ make_iprintf(k, o, rest$4); - /*<>*/ return function(_br_){ + /*<>*/ return function(_bs_){ /*<>*/ return x$5;} /*<>*/ ; } - /*<>*/ if(0 === _bf_[0]){ + /*<>*/ if(0 === _bg_[0]){ var rest$5 = fmt[2], x$6 = /*<>*/ make_iprintf(k, o, rest$5); - /*<>*/ return function(_bq_){ + /*<>*/ return function(_br_){ /*<>*/ return x$6;} /*<>*/ ; } var @@ -18308,49 +18288,49 @@ x$7 = /*<>*/ make_iprintf(k, o, rest$6), x$8 = - /*<>*/ function(_bp_){ + /*<>*/ function(_bq_){ /*<>*/ return x$7; }; - /*<>*/ return function(_bo_){ + /*<>*/ return function(_bp_){ /*<>*/ return x$8;} /*<>*/ ; } - var _be_ = /*<>*/ fmt[1]; - if(typeof _be_ === "number"){ + var _bf_ = /*<>*/ fmt[1]; + if(typeof _bf_ === "number"){ var rest$1 = fmt[2], x$1 = /*<>*/ make_iprintf(k, o, rest$1); - /*<>*/ return function(_bn_){ + /*<>*/ return function(_bo_){ /*<>*/ return x$1;} /*<>*/ ; } - /*<>*/ if(0 === _be_[0]){ + /*<>*/ if(0 === _bf_[0]){ var rest$2 = fmt[2], x$2 = /*<>*/ make_iprintf(k, o, rest$2); - /*<>*/ return function(_bm_){ + /*<>*/ return function(_bn_){ /*<>*/ return x$2;} /*<>*/ ; } var rest$3 = /*<>*/ fmt[2], x$3 = /*<>*/ make_iprintf(k, o, rest$3), x$4 = - /*<>*/ function(_bl_){ + /*<>*/ function(_bm_){ /*<>*/ return x$3; }; - /*<>*/ return function(_bk_){ + /*<>*/ return function(_bl_){ /*<>*/ return x$4;} /*<>*/ ; } var rest$0 = /*<>*/ fmt[1], x$0 = /*<>*/ make_iprintf(k, o, rest$0); - /*<>*/ return function(_bj_){ + /*<>*/ return function(_bk_){ /*<>*/ return x$0;} /*<>*/ ; } var rest = /*<>*/ fmt[1], x = /*<>*/ make_iprintf(k, o, rest); - /*<>*/ return function(_bi_){ + /*<>*/ return function(_bj_){ /*<>*/ return x;} /*<>*/ ; /*<>*/ } function make_iprintf(k, o, fmt){ @@ -18363,71 +18343,71 @@ if(typeof prec !== "number"){ var x$2 = /*<>*/ make_iprintf(k, o, fmt); - /*<>*/ return function(_bd_){ + /*<>*/ return function(_be_){ /*<>*/ return x$2;} /*<>*/ ; } /*<>*/ if(prec){ var x = /*<>*/ make_iprintf(k, o, fmt), x$0 = - /*<>*/ function(_bc_){ + /*<>*/ function(_bd_){ /*<>*/ return x; }; - /*<>*/ return function(_bb_){ + /*<>*/ return function(_bc_){ /*<>*/ return x$0;} /*<>*/ ; } var x$1 = /*<>*/ make_iprintf(k, o, fmt); - /*<>*/ return function(_ba_){ + /*<>*/ return function(_bb_){ /*<>*/ return x$1;} /*<>*/ ; } /*<>*/ if(0 === pad[0]){ if(typeof prec !== "number"){ var x$6 = /*<>*/ make_iprintf(k, o, fmt); - /*<>*/ return function(_a$_){ + /*<>*/ return function(_ba_){ /*<>*/ return x$6;} /*<>*/ ; } /*<>*/ if(prec){ var x$3 = /*<>*/ make_iprintf(k, o, fmt), x$4 = - /*<>*/ function(_a__){ + /*<>*/ function(_a$_){ /*<>*/ return x$3; }; - /*<>*/ return function(_a9_){ + /*<>*/ return function(_a__){ /*<>*/ return x$4;} /*<>*/ ; } var x$5 = /*<>*/ make_iprintf(k, o, fmt); - /*<>*/ return function(_a8_){ + /*<>*/ return function(_a9_){ /*<>*/ return x$5;} /*<>*/ ; } /*<>*/ if(typeof prec !== "number"){ var x$12 = /*<>*/ make_iprintf(k, o, fmt), x$13 = - /*<>*/ function(_a7_){ + /*<>*/ function(_a8_){ /*<>*/ return x$12; }; - /*<>*/ return function(_a6_){ + /*<>*/ return function(_a7_){ /*<>*/ return x$13;} /*<>*/ ; } /*<>*/ if(prec){ var x$7 = /*<>*/ make_iprintf(k, o, fmt), x$8 = - /*<>*/ function(_a5_){ + /*<>*/ function(_a6_){ /*<>*/ return x$7; }, x$9 = - /*<>*/ function(_a4_){ + /*<>*/ function(_a5_){ /*<>*/ return x$8; }; - /*<>*/ return function(_a3_){ + /*<>*/ return function(_a4_){ /*<>*/ return x$9;} /*<>*/ ; } var x$10 = /*<>*/ make_iprintf(k, o, fmt); - function x$11(_a2_){ /*<>*/ return x$10;} - /*<>*/ return function(_a1_){ + function x$11(_a3_){ /*<>*/ return x$10;} + /*<>*/ return function(_a2_){ /*<>*/ return x$11;} /*<>*/ ; /*<>*/ } function fn_of_custom_arity$0(counter, k, o, fmt, param){ @@ -18437,7 +18417,7 @@ x = /*<>*/ fn_of_custom_arity (k, o, fmt, arity); - /*<>*/ return function(_a0_){ + /*<>*/ return function(_a1_){ /*<>*/ return x;} /*<>*/ ; } /*<>*/ if(counter >= 50) @@ -18613,9 +18593,9 @@ case 6: var f = /*<>*/ acc[2], p$3 = acc[1]; /*<>*/ strput_acc(b, p$3); - var _aZ_ = /*<>*/ caml_call1(f, 0); + var _a0_ = /*<>*/ caml_call1(f, 0); /*<>*/ return caml_call2 - (Stdlib_Buffer[16], b, _aZ_) /*<>*/ ; + (Stdlib_Buffer[16], b, _a0_) /*<>*/ ; case 7: var acc$2 = /*<>*/ acc[1]; /*<>*/ acc = acc$2; @@ -18648,10 +18628,10 @@ function k(acc){ /*<>*/ strput_acc(buf, acc); var - _aY_ = + _aZ_ = /*<>*/ caml_call1 (Stdlib_Buffer[2], buf); - /*<>*/ return caml_call1(Stdlib[2], _aY_); + /*<>*/ return caml_call1(Stdlib[2], _aZ_); } /*<>*/ return make_printf(k, 0, fmt) /*<>*/ ; } @@ -18711,11 +18691,11 @@ else /*<>*/ try{ var - _aX_ = + _aY_ = /*<>*/ /*<>*/ runtime.caml_int_of_string ( /*<>*/ caml_call3 (Stdlib_String[16], str, nstart, nend - nstart | 0)), - indent = _aX_; + indent = _aY_; } catch(exn$0){ var exn = /*<>*/ caml_wrap_exception(exn$0); @@ -18805,377 +18785,42 @@ (failwith_message(_B_), str, str_ind, expected, read) /*<>*/ ; } function parse(lit_start, end_ind){ - a: - { - var str_ind = /*<>*/ lit_start; - for(;;){ - /*<>*/ if(str_ind === end_ind) - /*<>*/ return add_literal - (lit_start, str_ind, 0) /*<>*/ ; - var - match = - /*<>*/ caml_string_get(str, str_ind); - /*<>*/ if(37 === match) break; - if(64 === match) break a; - var str_ind$1 = /*<>*/ str_ind + 1 | 0; - str_ind = str_ind$1; - } - var str_ind$2 = /*<>*/ str_ind + 1 | 0; - /*<>*/ if(str_ind$2 === end_ind) - /*<>*/ invalid_format_message - (end_ind, cst_unexpected_end_of_format); - var - match$0 = - /*<>*/ 95 - === caml_string_get(str, str_ind$2) - ? /*<>*/ parse_flags - (str_ind, str_ind$2 + 1 | 0, end_ind, 1) - : /*<>*/ parse_flags - (str_ind, str_ind$2, end_ind, 0), - fmt_rest = /*<>*/ match$0[1]; - /*<>*/ return add_literal - (lit_start, str_ind, fmt_rest) /*<>*/ ; - } - var str_ind$0 = /*<>*/ str_ind + 1 | 0; - a: - if(str_ind$0 === end_ind) - var match$1 = /*<>*/ _N_; - else{ + var str_ind = /*<>*/ lit_start; + for(;;){ + /*<>*/ if(str_ind === end_ind) + /*<>*/ return add_literal + (lit_start, str_ind, 0) /*<>*/ ; var - c = - /*<>*/ caml_string_get - (str, str_ind$0); - /*<>*/ if(65 <= c){ - if(94 <= c){ - var switcher = c - 123 | 0; - if(2 >= switcher >>> 0) - switch(switcher){ - case 0: - var - match$1 = - /*<>*/ parse_tag - (1, str_ind$0 + 1 | 0, end_ind); - break a; - case 2: - var - fmt_rest$2 = - /*<>*/ parse - (str_ind$0 + 1 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, 1, fmt_rest$2]]; - break a; - } - } - else if(91 <= c) - /*<>*/ switch(c - 91 | 0){ - case 0: - var - match$1 = - /*<>*/ parse_tag - (0, str_ind$0 + 1 | 0, end_ind); - break a; - case 2: - var - fmt_rest$3 = - /*<>*/ parse - (str_ind$0 + 1 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, 0, fmt_rest$3]]; - break a; - } - } - else{ - /*<>*/ if(10 === c){ - var - fmt_rest$4 = - /*<>*/ parse - (str_ind$0 + 1 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, 3, fmt_rest$4]]; - break a; - } - /*<>*/ if(32 <= c) - switch(c - 32 | 0){ - case 0: - var - fmt_rest$5 = - /*<>*/ parse - (str_ind$0 + 1 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, _O_, fmt_rest$5]]; - break a; - case 5: - /*<>*/ if - ((str_ind$0 + 1 | 0) < end_ind - && - 37 - === - /*<>*/ caml_string_get - (str, str_ind$0 + 1 | 0)){ - var - fmt_rest$6 = - /*<>*/ parse - (str_ind$0 + 2 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, 6, fmt_rest$6]]; - break a; - } - var - fmt_rest$7 = - /*<>*/ parse(str_ind$0, end_ind) - [1], - match$1 = - /*<>*/ [0, [12, 64, fmt_rest$7]]; - break a; - case 12: - var - fmt_rest$8 = - /*<>*/ parse - (str_ind$0 + 1 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, _P_, fmt_rest$8]]; - break a; - case 14: - var - fmt_rest$9 = - /*<>*/ parse - (str_ind$0 + 1 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, 4, fmt_rest$9]]; - break a; - case 27: - var - str_ind$3 = - /*<>*/ str_ind$0 + 1 | 0; - b: - try{ - var - _aP_ = str_ind$3 === end_ind ? 1 : 0, - _aQ_ = - _aP_ - || - (60 - !== - /*<>*/ caml_string_get - (str, str_ind$3) - ? 1 - : 0); - if(_aQ_) - /*<>*/ throw caml_maybe_attach_backtrace - (Stdlib[8], 1); - var - str_ind_1 = - /*<>*/ parse_spaces - (str_ind$3 + 1 | 0, end_ind), - match$2 = - /*<>*/ caml_string_get - (str, str_ind_1); - c: - { - /*<>*/ if(48 <= match$2){ - if(58 <= match$2) break c; - } - else if(45 !== match$2) break c; - var - match$3 = - /*<>*/ parse_integer - (str_ind_1, end_ind), - width = /*<>*/ match$3[2], - str_ind_2 = match$3[1], - str_ind_3 = - /*<>*/ parse_spaces - (str_ind_2, end_ind), - switcher$0 = - /*<>*/ caml_string_get - (str, str_ind_3) - - 45 - | 0; - /*<>*/ if(12 < switcher$0 >>> 0){ - if(17 === switcher$0){ - var - s = - /*<>*/ caml_call3 - (Stdlib_String[16], - str, - str_ind$3 - 2 | 0, - (str_ind_3 - str_ind$3 | 0) + 3 | 0), - _aR_ = /*<>*/ [0, s, width, 0], - _aS_ = str_ind_3 + 1 | 0, - formatting_lit$0 = _aR_, - next_ind = _aS_; - break b; - } - } - else if(1 < switcher$0 - 1 >>> 0){ - var - match$4 = - /*<>*/ parse_integer - (str_ind_3, end_ind), - offset = /*<>*/ match$4[2], - str_ind_4 = match$4[1], - str_ind_5 = - /*<>*/ parse_spaces - (str_ind_4, end_ind); - /*<>*/ if - (62 !== caml_string_get(str, str_ind_5)) - /*<>*/ throw caml_maybe_attach_backtrace - (Stdlib[8], 1); - var - s$0 = - /*<>*/ caml_call3 - (Stdlib_String[16], - str, - str_ind$3 - 2 | 0, - (str_ind_5 - str_ind$3 | 0) + 3 | 0), - _aT_ = - /*<>*/ [0, - s$0, - width, - offset], - _aU_ = str_ind_5 + 1 | 0, - formatting_lit$0 = _aT_, - next_ind = _aU_; - break b; - } - /*<>*/ throw caml_maybe_attach_backtrace - (Stdlib[8], 1); - } - /*<>*/ throw caml_maybe_attach_backtrace - (Stdlib[8], 1); - } - catch(exn$0){ - var exn = /*<>*/ caml_wrap_exception(exn$0); - if(exn === Stdlib[8]) - var formatting_lit$0 = formatting_lit, next_ind = str_ind$3; - else{ - if(exn[1] !== Stdlib[7]) - throw caml_maybe_attach_backtrace(exn, 0); - var formatting_lit$0 = formatting_lit, next_ind = str_ind$3; - } - } - var - fmt_rest$12 = - /*<>*/ parse(next_ind, end_ind) - [1], - match$1 = - /*<>*/ [0, - [17, formatting_lit$0, fmt_rest$12]]; - break a; - case 28: - var - str_ind$4 = - /*<>*/ str_ind$0 + 1 | 0; - try{ - var - str_ind_1$0 = - /*<>*/ parse_spaces - (str_ind$4, end_ind), - match$6 = - /*<>*/ caml_string_get - (str, str_ind_1$0); - b: - { - c: - { - /*<>*/ if(48 <= match$6){ - if(58 <= match$6) break c; - } - else if(45 !== match$6) break c; - var - match$7 = - /*<>*/ parse_integer - (str_ind_1$0, end_ind), - size = /*<>*/ match$7[2], - str_ind_2$0 = match$7[1], - str_ind_3$0 = - /*<>*/ parse_spaces - (str_ind_2$0, end_ind); - /*<>*/ if - (62 !== caml_string_get(str, str_ind_3$0)) - /*<>*/ throw caml_maybe_attach_backtrace - (Stdlib[8], 1); - var - s$1 = - /*<>*/ caml_call3 - (Stdlib_String[16], - str, - str_ind$4 - 2 | 0, - (str_ind_3$0 - str_ind$4 | 0) + 3 | 0), - _aW_ = - /*<>*/ [0, - [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]]; - break b; - } - var _aW_ = /*<>*/ 0; - } - var _aV_ = _aW_; - } - catch(exn){ - var exn$0 = /*<>*/ caml_wrap_exception(exn); - if(exn$0 !== Stdlib[8] && exn$0[1] !== Stdlib[7]) - throw caml_maybe_attach_backtrace(exn$0, 0); - var _aV_ = /*<>*/ 0; - } - /*<>*/ if(_aV_){ - var - match$5 = _aV_[1], - formatting_lit$1 = match$5[2], - next_ind$0 = match$5[1], - fmt_rest$13 = - /*<>*/ parse - (next_ind$0, end_ind) - [1], - match$1 = - /*<>*/ [0, - [17, formatting_lit$1, fmt_rest$13]]; - break a; - } - var - fmt_rest$14 = - /*<>*/ parse(str_ind$4, end_ind) - [1], - match$1 = - /*<>*/ [0, - [17, _Q_, fmt_rest$14]]; - break a; - case 31: - var - fmt_rest$10 = - /*<>*/ parse - (str_ind$0 + 1 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, 2, fmt_rest$10]]; - break a; - case 32: - var - fmt_rest$11 = - /*<>*/ parse - (str_ind$0 + 1 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, 5, fmt_rest$11]]; - break a; - } + match = + /*<>*/ caml_string_get(str, str_ind); + /*<>*/ if(37 === match) break; + if(64 === match){ + var + fmt_rest$0 = + /*<>*/ parse_after_at + (str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return add_literal + (lit_start, str_ind, fmt_rest$0) /*<>*/ ; } - var - fmt_rest$1 = - /*<>*/ parse - (str_ind$0 + 1 | 0, end_ind) - [1], - match$1 = - /*<>*/ [0, [17, [2, c], fmt_rest$1]]; + var str_ind$0 = /*<>*/ str_ind + 1 | 0; + str_ind = str_ind$0; } - var fmt_rest$0 = /*<>*/ match$1[1]; - /*<>*/ return add_literal - (lit_start, str_ind, fmt_rest$0) /*<>*/ ; + var str_ind$1 = /*<>*/ str_ind + 1 | 0; + /*<>*/ if(str_ind$1 === end_ind) + /*<>*/ invalid_format_message + (end_ind, cst_unexpected_end_of_format); + var + match$0 = + /*<>*/ 95 + === caml_string_get(str, str_ind$1) + ? /*<>*/ parse_flags + (str_ind, str_ind$1 + 1 | 0, end_ind, 1) + : /*<>*/ parse_flags + (str_ind, str_ind$1, end_ind, 0), + fmt_rest = /*<>*/ match$0[1]; + /*<>*/ return add_literal + (lit_start, str_ind, fmt_rest) /*<>*/ ; } function parse_flags(pct_ind, str_ind, end_ind, ign){ var @@ -19186,14 +18831,14 @@ hash = [0, 0]; function set_flag(str_ind, flag){ var - _aM_ = /*<>*/ flag[1], - _aN_ = _aM_ ? 1 - legacy_behavior$0 : _aM_; - if(_aN_){ + _aV_ = /*<>*/ flag[1], + _aW_ = _aV_ ? 1 - legacy_behavior$0 : _aV_; + if(_aW_){ var - _aO_ = + _aX_ = /*<>*/ caml_string_get(str, str_ind); /*<>*/ caml_call3 - (failwith_message(_C_), str, str_ind, _aO_); + (failwith_message(_C_), str, str_ind, _aX_); } /*<>*/ flag[1] = 1; /*<>*/ } @@ -19405,9 +19050,9 @@ case 3: /*<>*/ if(legacy_behavior$0){ var - _aL_ = /*<>*/ str_ind$0 + 1 | 0, + _aU_ = /*<>*/ str_ind$0 + 1 | 0, minus$0 = minus || (45 === symb$0 ? 1 : 0); - return parse_literal(minus$0, _aL_) /*<>*/ ; + return parse_literal(minus$0, _aU_) /*<>*/ ; } break; } @@ -19690,6 +19335,35 @@ /*<>*/ [0, [3, pad$7, fmt_rest$16]]; break a; + case 91: + var + match$7 = + /*<>*/ parse_char_set + (str_ind, end_ind), + char_set = /*<>*/ match$7[2], + next_ind = match$7[1], + fmt_rest$19 = + /*<>*/ parse(next_ind, end_ind) + [1]; + /*<>*/ if(get_ign(0)){ + var + ignored$9 = + /*<>*/ [10, + get_pad_opt(95), + char_set], + fmt_result = + /*<>*/ [0, + [23, ignored$9, fmt_rest$19]]; + break a; + } + var + fmt_result = + /*<>*/ [0, + [20, + /*<>*/ get_pad_opt(91), + char_set, + fmt_rest$19]]; + break a; case 97: var fmt_rest$20 = @@ -19699,23 +19373,23 @@ break a; case 99: var - char_format = - /*<>*/ function(fmt_rest){ - /*<>*/ return get_ign(0) - ? [0, [23, 0, fmt_rest]] - : [0, [0, fmt_rest]] /*<>*/ ; - }, fmt_rest$21 = /*<>*/ parse(str_ind, end_ind)[1], - match$7 = /*<>*/ get_pad_opt(99); - /*<>*/ if(! match$7){ + match$8 = /*<>*/ get_pad_opt(99); + /*<>*/ if(! match$8){ + /*<>*/ if(get_ign(0)){ + var + fmt_result = + /*<>*/ [0, + [23, 0, fmt_rest$21]]; + break a; + } var fmt_result = - /*<>*/ /*<>*/ char_format - (fmt_rest$21); + /*<>*/ [0, [0, fmt_rest$21]]; break a; } - /*<>*/ if(0 === match$7[1]){ + /*<>*/ if(0 === match$8[1]){ /*<>*/ if(get_ign(0)){ var fmt_result = @@ -19728,17 +19402,22 @@ /*<>*/ [0, [22, fmt_rest$21]]; break a; } - /*<>*/ if(legacy_behavior$0){ + /*<>*/ if(! legacy_behavior$0){ var fmt_result = - /*<>*/ /*<>*/ char_format - (fmt_rest$21); + /*<>*/ invalid_format_message + (str_ind, cst_non_zero_widths_are_unsupp); + break a; + } + /*<>*/ if(get_ign(0)){ + var + fmt_result = + /*<>*/ [0, [23, 0, fmt_rest$21]]; break a; } var fmt_result = - /*<>*/ invalid_format_message - (str_ind, cst_non_zero_widths_are_unsupp); + /*<>*/ [0, [0, fmt_rest$21]]; break a; case 114: var @@ -19771,11 +19450,11 @@ break a; } var - match$8 = + match$9 = /*<>*/ make_padding_fmt_ebb (pad$9, fmt_rest$23), - fmt_rest$24 = /*<>*/ match$8[2], - pad$10 = match$8[1], + fmt_rest$24 = /*<>*/ match$9[2], + pad$10 = match$9[1], fmt_result = /*<>*/ [0, [2, pad$10, fmt_rest$24]]; @@ -19820,233 +19499,6 @@ sub_fmtty$0, fmt_rest$26]]; break a; - case 91: - /*<>*/ if(str_ind === end_ind) - /*<>*/ invalid_format_message - (end_ind, cst_unexpected_end_of_format); - var - char_set = - /*<>*/ create_char_set(0), - add_range = - /*<>*/ function(c$0, c){ - /*<>*/ if(c >= c$0){ - var i = c$0; - for(;;){ - /*<>*/ /*<>*/ add_in_char_set - (char_set, - /*<>*/ caml_call1 - (Stdlib[29], i)); - var _aK_ = /*<>*/ i + 1 | 0; - if(c === i) break; - i = _aK_; - } - } - /*<>*/ }, - fail_single_percent = - /*<>*/ function(str_ind){ - /*<>*/ return caml_call2 - (failwith_message(_R_), str, str_ind) /*<>*/ ; - }, - parse_char_set_content = - /*<>*/ function - (counter, str_ind$1, end_ind){ - var str_ind = /*<>*/ str_ind$1; - for(;;){ - if(str_ind === end_ind) - /*<>*/ invalid_format_message - (end_ind, cst_unexpected_end_of_format); - var - c = - /*<>*/ caml_string_get - (str, str_ind); - /*<>*/ if(45 !== c){ - if(93 === c) - /*<>*/ return str_ind + 1 | 0; - var - _aJ_ = /*<>*/ str_ind + 1 | 0; - if(counter >= 50) - return caml_trampoline_return - (parse_char_set_after_char$0, [0, _aJ_, end_ind, c]) /*<>*/ ; - var - counter$0 = - /*<>*/ counter + 1 | 0; - return parse_char_set_after_char$0 - (counter$0, _aJ_, end_ind, c) /*<>*/ ; - } - /*<>*/ add_in_char_set - (char_set, 45); - var - str_ind$0 = - /*<>*/ str_ind + 1 | 0; - str_ind = str_ind$0; - } - /*<>*/ }, - parse_char_set_after_char$0 = - /*<>*/ function - (counter, str_ind$2, end_ind, c$3){ - var - str_ind = /*<>*/ str_ind$2, - c = c$3; - for(;;){ - if(str_ind === end_ind) - /*<>*/ invalid_format_message - (end_ind, cst_unexpected_end_of_format); - var - c$0 = - /*<>*/ caml_string_get - (str, str_ind); - a: - { - /*<>*/ if(46 <= c$0){ - if(64 !== c$0){ - if(93 !== c$0) break a; - /*<>*/ add_in_char_set - (char_set, c); - /*<>*/ return str_ind + 1 - | 0; - } - } - else if(37 !== c$0){ - /*<>*/ if(45 <= c$0) break; - break a; - } - /*<>*/ if(37 === c){ - /*<>*/ add_in_char_set - (char_set, c$0); - var - _aG_ = - /*<>*/ str_ind + 1 | 0; - if(counter >= 50) - return caml_trampoline_return - (parse_char_set_content, [0, _aG_, end_ind]) /*<>*/ ; - var - counter$2 = - /*<>*/ counter + 1 | 0; - return parse_char_set_content(counter$2, _aG_, end_ind) /*<>*/ ; - } - } - /*<>*/ if(37 === c) - /*<>*/ fail_single_percent - (str_ind); - /*<>*/ add_in_char_set - (char_set, c); - var - str_ind$0 = - /*<>*/ str_ind + 1 | 0; - str_ind = str_ind$0; - c = c$0; - } - var - str_ind$1 = - /*<>*/ str_ind + 1 | 0; - /*<>*/ if(str_ind$1 === end_ind) - /*<>*/ invalid_format_message - (end_ind, cst_unexpected_end_of_format); - var - c$1 = - /*<>*/ caml_string_get - (str, str_ind$1); - /*<>*/ if(37 === c$1){ - /*<>*/ if - ((str_ind$1 + 1 | 0) === end_ind) - /*<>*/ invalid_format_message - (end_ind, cst_unexpected_end_of_format); - var - c$2 = - /*<>*/ caml_string_get - (str, str_ind$1 + 1 | 0); - /*<>*/ if - (37 !== c$2 && 64 !== c$2) - /*<>*/ return fail_single_percent - (str_ind$1) /*<>*/ ; - /*<>*/ add_range(c, c$2); - var - _aH_ = - /*<>*/ str_ind$1 + 2 | 0; - if(counter >= 50) - return caml_trampoline_return - (parse_char_set_content, [0, _aH_, end_ind]) /*<>*/ ; - var - counter$1 = - /*<>*/ counter + 1 | 0; - return parse_char_set_content(counter$1, _aH_, end_ind) /*<>*/ ; - } - /*<>*/ if(93 === c$1){ - /*<>*/ add_in_char_set - (char_set, c); - add_in_char_set(char_set, 45); - /*<>*/ return str_ind$1 + 1 | 0; - } - /*<>*/ add_range(c, c$1); - var - _aI_ = /*<>*/ str_ind$1 + 1 | 0; - if(counter >= 50) - return caml_trampoline_return - (parse_char_set_content, [0, _aI_, end_ind]) /*<>*/ ; - var - counter$0 = - /*<>*/ counter + 1 | 0; - return parse_char_set_content(counter$0, _aI_, end_ind) /*<>*/ ; - }, - parse_char_set_after_char = - /*<>*/ function - (str_ind, end_ind, c){ - /*<>*/ return /*<>*/ caml_trampoline - ( /*<>*/ parse_char_set_after_char$0 - (0, str_ind, end_ind, c)) /*<>*/ ; - }; - /*<>*/ if(str_ind === end_ind) - /*<>*/ invalid_format_message - (end_ind, cst_unexpected_end_of_format); - /*<>*/ if - (94 === caml_string_get(str, str_ind)) - var - str_ind$0 = /*<>*/ str_ind + 1 | 0, - reverse = /*<>*/ 1, - str_ind$1 = str_ind$0; - else - var - reverse = /*<>*/ 0, - str_ind$1 = str_ind; - /*<>*/ if(str_ind$1 === end_ind) - /*<>*/ invalid_format_message - (end_ind, cst_unexpected_end_of_format); - var - c = - /*<>*/ caml_string_get - (str, str_ind$1), - next_ind = - /*<>*/ parse_char_set_after_char - (str_ind$1 + 1 | 0, end_ind, c), - char_set$0 = - /*<>*/ freeze_char_set(char_set), - char_set$1 = - /*<>*/ reverse - ? /*<>*/ rev_char_set - (char_set$0) - : char_set$0, - fmt_rest$19 = - /*<>*/ parse(next_ind, end_ind) - [1]; - /*<>*/ if(get_ign(0)){ - var - ignored$9 = - /*<>*/ [10, - get_pad_opt(95), - char_set$1], - fmt_result = - /*<>*/ [0, - [23, ignored$9, fmt_rest$19]]; - break a; - } - var - fmt_result = - /*<>*/ [0, - [20, - /*<>*/ get_pad_opt(91), - char_set$1, - fmt_rest$19]]; - break a; case 66: case 98: var @@ -20089,22 +19541,22 @@ symb$0 = /*<>*/ caml_string_get (str, str_ind), - _aF_ = /*<>*/ symb$0 - 88 | 0; + _aT_ = /*<>*/ symb$0 - 88 | 0; b: { - if(32 >= _aF_ >>> 0) - switch(_aF_){ + if(32 >= _aT_ >>> 0) + switch(_aT_){ case 0: case 12: case 17: case 23: case 29: case 32: - var _aB_ = /*<>*/ 1; break b; + var _aP_ = /*<>*/ 1; break b; } - var _aB_ = /*<>*/ 0; + var _aP_ = /*<>*/ 0; } - /*<>*/ if(_aB_) break; + /*<>*/ if(_aP_) break; } var fmt_rest$13 = @@ -20159,15 +19611,15 @@ case 117: case 120: var - _aC_ = /*<>*/ get_space(0), - _aD_ = /*<>*/ get_hash(0), + _aQ_ = /*<>*/ get_space(0), + _aR_ = /*<>*/ get_hash(0), iconv$2 = /*<>*/ /*<>*/ compute_int_conv (pct_ind, str_ind, /*<>*/ get_plus(0), - _aD_, - _aC_, + _aR_, + _aQ_, symb), fmt_rest$17 = /*<>*/ parse(str_ind, end_ind)[1]; @@ -20183,11 +19635,11 @@ break a; } var - _aE_ = /*<>*/ get_prec(0), + _aS_ = /*<>*/ get_prec(0), match$6 = /*<>*/ /*<>*/ make_padprec_fmt_ebb ( /*<>*/ get_int_pad(0), - _aE_, + _aS_, fmt_rest$17), fmt_rest$18 = /*<>*/ match$6[3], prec$4 = match$6[2], @@ -20261,11 +19713,11 @@ /*<>*/ parse(str_ind, end_ind)[1]; /*<>*/ if(! get_ign(0)){ var - _aA_ = /*<>*/ get_prec(0), + _aO_ = /*<>*/ get_prec(0), match$4 = /*<>*/ /*<>*/ make_padprec_fmt_ebb ( /*<>*/ get_pad(0), - _aA_, + _aO_, fmt_rest$11), fmt_rest$12 = /*<>*/ match$4[3], prec$3 = match$4[2], @@ -20278,7 +19730,7 @@ var match = /*<>*/ get_prec(0); /*<>*/ if(typeof match === "number") var - _az_ = + _aN_ = match ? /*<>*/ incompatible_flag (pct_ind, str_ind, 95, cst$26) @@ -20286,10 +19738,10 @@ else var ndec = /*<>*/ match[1], - _az_ = /*<>*/ [0, ndec]; + _aN_ = /*<>*/ [0, ndec]; var ignored$4 = - /*<>*/ [6, get_pad_opt(95), _az_], + /*<>*/ [6, get_pad_opt(95), _aN_], fmt_result = /*<>*/ [0, [23, ignored$4, fmt_rest$11]]; @@ -20300,19 +19752,19 @@ switch(symb - 108 | 0){ case 0: var - _an_ = + _aB_ = /*<>*/ caml_string_get (str, str_ind), - _ao_ = /*<>*/ get_space(0), - _ap_ = /*<>*/ get_hash(0), + _aC_ = /*<>*/ get_space(0), + _aD_ = /*<>*/ get_hash(0), iconv = /*<>*/ /*<>*/ compute_int_conv (pct_ind, str_ind + 1 | 0, /*<>*/ get_plus(0), - _ap_, - _ao_, - _an_), + _aD_, + _aC_, + _aB_), fmt_rest = /*<>*/ parse (str_ind + 1 | 0, end_ind) @@ -20329,11 +19781,11 @@ break a; } var - _aq_ = /*<>*/ get_prec(0), + _aE_ = /*<>*/ get_prec(0), match$0 = /*<>*/ /*<>*/ make_padprec_fmt_ebb ( /*<>*/ get_int_pad(0), - _aq_, + _aE_, fmt_rest), fmt_rest$0 = /*<>*/ match$0[3], prec$0 = match$0[2], @@ -20344,19 +19796,19 @@ break a; case 2: var - _ar_ = + _aF_ = /*<>*/ caml_string_get (str, str_ind), - _as_ = /*<>*/ get_space(0), - _at_ = /*<>*/ get_hash(0), + _aG_ = /*<>*/ get_space(0), + _aH_ = /*<>*/ get_hash(0), iconv$0 = /*<>*/ /*<>*/ compute_int_conv (pct_ind, str_ind + 1 | 0, /*<>*/ get_plus(0), - _at_, - _as_, - _ar_), + _aH_, + _aG_, + _aF_), fmt_rest$1 = /*<>*/ parse (str_ind + 1 | 0, end_ind) @@ -20373,11 +19825,11 @@ break a; } var - _au_ = /*<>*/ get_prec(0), + _aI_ = /*<>*/ get_prec(0), match$1 = /*<>*/ /*<>*/ make_padprec_fmt_ebb ( /*<>*/ get_int_pad(0), - _au_, + _aI_, fmt_rest$1), fmt_rest$2 = /*<>*/ match$1[3], prec$1 = match$1[2], @@ -20390,18 +19842,18 @@ } else if(76 === symb){ var - _av_ = + _aJ_ = /*<>*/ caml_string_get(str, str_ind), - _aw_ = /*<>*/ get_space(0), - _ax_ = /*<>*/ get_hash(0), + _aK_ = /*<>*/ get_space(0), + _aL_ = /*<>*/ get_hash(0), iconv$1 = /*<>*/ /*<>*/ compute_int_conv (pct_ind, str_ind + 1 | 0, /*<>*/ get_plus(0), - _ax_, - _aw_, - _av_), + _aL_, + _aK_, + _aJ_), fmt_rest$3 = /*<>*/ parse (str_ind + 1 | 0, end_ind) @@ -20418,11 +19870,11 @@ break a; } var - _ay_ = /*<>*/ get_prec(0), + _aM_ = /*<>*/ get_prec(0), match$2 = /*<>*/ /*<>*/ make_padprec_fmt_ebb ( /*<>*/ get_int_pad(0), - _ay_, + _aM_, fmt_rest$3), fmt_rest$4 = /*<>*/ match$2[3], prec$2 = match$2[2], @@ -20439,43 +19891,43 @@ } /*<>*/ if(1 - legacy_behavior$0){ var - _ae_ = /*<>*/ 1 - plus_used[1], - plus$0 = _ae_ ? plus : _ae_; + _as_ = /*<>*/ 1 - plus_used[1], + plus$0 = _as_ ? plus : _as_; if(plus$0) /*<>*/ incompatible_flag (pct_ind, str_ind, symb, cst$27); var - _af_ = /*<>*/ 1 - hash_used[1], - hash$0 = _af_ ? hash : _af_; + _at_ = /*<>*/ 1 - hash_used[1], + hash$0 = _at_ ? hash : _at_; if(hash$0) /*<>*/ incompatible_flag (pct_ind, str_ind, symb, cst$28); var - _ag_ = /*<>*/ 1 - space_used[1], - space$0 = _ag_ ? space : _ag_; + _au_ = /*<>*/ 1 - space_used[1], + space$0 = _au_ ? space : _au_; if(space$0) /*<>*/ incompatible_flag (pct_ind, str_ind, symb, cst$29); var - _ah_ = /*<>*/ 1 - pad_used[1], - _ai_ = - _ah_ + _av_ = /*<>*/ 1 - pad_used[1], + _aw_ = + _av_ ? /*<>*/ caml_notequal ([0, pad], _K_) - : _ah_; - /*<>*/ if(_ai_) + : _av_; + /*<>*/ if(_aw_) /*<>*/ incompatible_flag (pct_ind, str_ind, symb, cst_padding$0); var - _aj_ = /*<>*/ 1 - prec_used[1], - _ak_ = - _aj_ + _ax_ = /*<>*/ 1 - prec_used[1], + _ay_ = + _ax_ ? /*<>*/ caml_notequal ([0, prec], _L_) - : _aj_; - /*<>*/ if(_ak_){ - var _al_ = /*<>*/ ign ? 95 : symb; - incompatible_flag(pct_ind, str_ind, _al_, cst_precision$2); + : _ax_; + /*<>*/ if(_ay_){ + var _az_ = /*<>*/ ign ? 95 : symb; + incompatible_flag(pct_ind, str_ind, _az_, cst_precision$2); } var plus$1 = /*<>*/ ign ? plus : ign; if(plus$1) @@ -20483,8 +19935,8 @@ (pct_ind, str_ind, 95, cst$30); } var - _am_ = /*<>*/ 1 - ign_used[1], - ign$0 = _am_ ? ign : _am_; + _aA_ = /*<>*/ 1 - ign_used[1], + ign$0 = _aA_ ? ign : _aA_; a: if(ign$0){ b: @@ -20500,6 +19952,308 @@ } /*<>*/ return fmt_result; } + function parse_after_at(str_ind, end_ind){ + /*<>*/ if(str_ind === end_ind) + /*<>*/ return _N_; + var + c = /*<>*/ caml_string_get(str, str_ind); + /*<>*/ if(65 <= c){ + if(94 <= c){ + var switcher = c - 123 | 0; + if(2 >= switcher >>> 0) + switch(switcher){ + case 0: + /*<>*/ return parse_tag + (1, str_ind + 1 | 0, end_ind) /*<>*/ ; + case 2: + var + fmt_rest$0 = + /*<>*/ parse + (str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return [0, + [17, 1, fmt_rest$0]]; + } + } + else if(91 <= c) + /*<>*/ switch(c - 91 | 0){ + case 0: + /*<>*/ return parse_tag + (0, str_ind + 1 | 0, end_ind) /*<>*/ ; + case 2: + var + fmt_rest$1 = + /*<>*/ parse + (str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return [0, + [17, 0, fmt_rest$1]]; + } + } + else{ + /*<>*/ if(10 === c){ + var + fmt_rest$2 = + /*<>*/ parse + (str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return [0, [17, 3, fmt_rest$2]]; + } + /*<>*/ if(32 <= c) + switch(c - 32 | 0){ + case 0: + var + fmt_rest$3 = + /*<>*/ parse + (str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return [0, + [17, _O_, fmt_rest$3]]; + case 5: + /*<>*/ if + ((str_ind + 1 | 0) < end_ind + && + 37 + === + /*<>*/ caml_string_get + (str, str_ind + 1 | 0)){ + var + fmt_rest$4 = + /*<>*/ parse + (str_ind + 2 | 0, end_ind) + [1]; + /*<>*/ return [0, + [17, 6, fmt_rest$4]]; + } + var + fmt_rest$5 = + /*<>*/ parse(str_ind, end_ind)[1]; + /*<>*/ return [0, + [12, 64, fmt_rest$5]]; + case 12: + var + fmt_rest$6 = + /*<>*/ parse + (str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return [0, + [17, _P_, fmt_rest$6]]; + case 14: + var + fmt_rest$7 = + /*<>*/ parse + (str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return [0, + [17, 4, fmt_rest$7]]; + case 27: + var + str_ind$0 = /*<>*/ str_ind + 1 | 0; + a: + try{ + var + _ak_ = str_ind$0 === end_ind ? 1 : 0, + _al_ = + _ak_ + || + (60 + !== + /*<>*/ caml_string_get + (str, str_ind$0) + ? 1 + : 0); + if(_al_) + /*<>*/ throw caml_maybe_attach_backtrace + (Stdlib[8], 1); + var + str_ind_1 = + /*<>*/ parse_spaces + (str_ind$0 + 1 | 0, end_ind), + match = + /*<>*/ caml_string_get + (str, str_ind_1); + b: + { + /*<>*/ if(48 <= match){ + if(58 <= match) break b; + } + else if(45 !== match) break b; + var + match$0 = + /*<>*/ parse_integer + (str_ind_1, end_ind), + width = /*<>*/ match$0[2], + str_ind_2 = match$0[1], + str_ind_3 = + /*<>*/ parse_spaces + (str_ind_2, end_ind), + switcher$0 = + /*<>*/ caml_string_get + (str, str_ind_3) + - 45 + | 0; + /*<>*/ if(12 < switcher$0 >>> 0){ + if(17 === switcher$0){ + var + s = + /*<>*/ caml_call3 + (Stdlib_String[16], + str, + str_ind$0 - 2 | 0, + (str_ind_3 - str_ind$0 | 0) + 3 | 0), + _am_ = /*<>*/ [0, s, width, 0], + _an_ = str_ind_3 + 1 | 0, + formatting_lit$0 = _am_, + next_ind = _an_; + break a; + } + } + else if(1 < switcher$0 - 1 >>> 0){ + var + match$1 = + /*<>*/ parse_integer + (str_ind_3, end_ind), + offset = /*<>*/ match$1[2], + str_ind_4 = match$1[1], + str_ind_5 = + /*<>*/ parse_spaces + (str_ind_4, end_ind); + /*<>*/ if + (62 !== caml_string_get(str, str_ind_5)) + /*<>*/ throw caml_maybe_attach_backtrace + (Stdlib[8], 1); + var + s$0 = + /*<>*/ caml_call3 + (Stdlib_String[16], + str, + str_ind$0 - 2 | 0, + (str_ind_5 - str_ind$0 | 0) + 3 | 0), + _ao_ = + /*<>*/ [0, s$0, width, offset], + _ap_ = str_ind_5 + 1 | 0, + formatting_lit$0 = _ao_, + next_ind = _ap_; + break a; + } + /*<>*/ throw caml_maybe_attach_backtrace + (Stdlib[8], 1); + } + /*<>*/ throw caml_maybe_attach_backtrace + (Stdlib[8], 1); + } + catch(exn$0){ + var exn = /*<>*/ caml_wrap_exception(exn$0); + if(exn === Stdlib[8]) + var formatting_lit$0 = formatting_lit, next_ind = str_ind$0; + else{ + if(exn[1] !== Stdlib[7]) + throw caml_maybe_attach_backtrace(exn, 0); + var formatting_lit$0 = formatting_lit, next_ind = str_ind$0; + } + } + var + fmt_rest$10 = + /*<>*/ parse(next_ind, end_ind) + [1]; + /*<>*/ return [0, + [17, formatting_lit$0, fmt_rest$10]]; + case 28: + var + str_ind$1 = /*<>*/ str_ind + 1 | 0; + try{ + var + str_ind_1$0 = + /*<>*/ parse_spaces + (str_ind$1, end_ind), + match$3 = + /*<>*/ caml_string_get + (str, str_ind_1$0); + a: + { + b: + { + /*<>*/ if(48 <= match$3){ + if(58 <= match$3) break b; + } + else if(45 !== match$3) break b; + var + match$4 = + /*<>*/ parse_integer + (str_ind_1$0, end_ind), + size = /*<>*/ match$4[2], + str_ind_2$0 = match$4[1], + str_ind_3$0 = + /*<>*/ parse_spaces + (str_ind_2$0, end_ind); + /*<>*/ if + (62 !== caml_string_get(str, str_ind_3$0)) + /*<>*/ throw caml_maybe_attach_backtrace + (Stdlib[8], 1); + var + s$1 = + /*<>*/ caml_call3 + (Stdlib_String[16], + str, + str_ind$1 - 2 | 0, + (str_ind_3$0 - str_ind$1 | 0) + 3 | 0), + _ar_ = + /*<>*/ [0, + [0, str_ind_3$0 + 1 | 0, [1, s$1, size]]]; + break a; + } + var _ar_ = /*<>*/ 0; + } + var _aq_ = _ar_; + } + catch(exn){ + var exn$0 = /*<>*/ caml_wrap_exception(exn); + if(exn$0 !== Stdlib[8] && exn$0[1] !== Stdlib[7]) + throw caml_maybe_attach_backtrace(exn$0, 0); + var _aq_ = /*<>*/ 0; + } + /*<>*/ if(_aq_){ + var + match$2 = _aq_[1], + formatting_lit$1 = match$2[2], + next_ind$0 = match$2[1], + fmt_rest$11 = + /*<>*/ parse + (next_ind$0, end_ind) + [1]; + /*<>*/ return [0, + [17, formatting_lit$1, fmt_rest$11]]; + } + var + fmt_rest$12 = + /*<>*/ parse(str_ind$1, end_ind) + [1]; + /*<>*/ return [0, + [17, _Q_, fmt_rest$12]]; + case 31: + var + fmt_rest$8 = + /*<>*/ parse + (str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return [0, + [17, 2, fmt_rest$8]]; + case 32: + var + fmt_rest$9 = + /*<>*/ parse + (str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return [0, + [17, 5, fmt_rest$9]]; + } + } + var + fmt_rest = + /*<>*/ parse(str_ind + 1 | 0, end_ind) + [1]; + /*<>*/ return [0, [17, [2, c], fmt_rest]]; + /*<>*/ } function parse_tag(is_open_tag, str_ind, end_ind){ /*<>*/ try{ if(str_ind === end_ind) @@ -20530,10 +20284,10 @@ /*<>*/ is_open_tag ? [0, sub_format$0] : [1, sub_format$0], - _ad_ = + _aj_ = /*<>*/ [0, [18, formatting$0, fmt_rest$0]]; - return _ad_; + return _aj_; } catch(exn$0){ var exn = /*<>*/ caml_wrap_exception(exn$0); @@ -20549,6 +20303,168 @@ [18, formatting, fmt_rest]]; } /*<>*/ } + function parse_char_set(str_ind, end_ind){ + /*<>*/ if(str_ind === end_ind) + /*<>*/ invalid_format_message + (end_ind, cst_unexpected_end_of_format); + var char_set = /*<>*/ create_char_set(0); + function add_range(c$0, c){ + /*<>*/ if(c >= c$0){ + var i = c$0; + for(;;){ + /*<>*/ /*<>*/ add_in_char_set + (char_set, + /*<>*/ caml_call1(Stdlib[29], i)); + var _ai_ = /*<>*/ i + 1 | 0; + if(c === i) break; + i = _ai_; + } + } + /*<>*/ } + function fail_single_percent(str_ind){ + /*<>*/ return caml_call2 + (failwith_message(_R_), str, str_ind) /*<>*/ ; + } + function parse_char_set_content(counter, str_ind$1, end_ind){ + var str_ind = /*<>*/ str_ind$1; + for(;;){ + if(str_ind === end_ind) + /*<>*/ invalid_format_message + (end_ind, cst_unexpected_end_of_format); + var + c = + /*<>*/ caml_string_get(str, str_ind); + /*<>*/ if(45 !== c){ + if(93 === c) + /*<>*/ return str_ind + 1 | 0; + var _ah_ = /*<>*/ str_ind + 1 | 0; + if(counter >= 50) + return caml_trampoline_return + (parse_char_set_after_char$0, [0, _ah_, end_ind, c]) /*<>*/ ; + var counter$0 = /*<>*/ counter + 1 | 0; + return parse_char_set_after_char$0(counter$0, _ah_, end_ind, c) /*<>*/ ; + } + /*<>*/ add_in_char_set(char_set, 45); + var str_ind$0 = /*<>*/ str_ind + 1 | 0; + str_ind = str_ind$0; + } + /*<>*/ } + function parse_char_set_after_char$0(counter, str_ind$2, end_ind, c$3){ + var str_ind = /*<>*/ str_ind$2, c = c$3; + for(;;){ + if(str_ind === end_ind) + /*<>*/ invalid_format_message + (end_ind, cst_unexpected_end_of_format); + var + c$0 = + /*<>*/ caml_string_get(str, str_ind); + a: + { + /*<>*/ if(46 <= c$0){ + if(64 !== c$0){ + if(93 !== c$0) break a; + /*<>*/ add_in_char_set(char_set, c); + /*<>*/ return str_ind + 1 | 0; + } + } + else if(37 !== c$0){ + /*<>*/ if(45 <= c$0) break; + break a; + } + /*<>*/ if(37 === c){ + /*<>*/ add_in_char_set(char_set, c$0); + var _ae_ = /*<>*/ str_ind + 1 | 0; + if(counter >= 50) + return caml_trampoline_return + (parse_char_set_content, [0, _ae_, end_ind]) /*<>*/ ; + var + counter$2 = /*<>*/ counter + 1 | 0; + return parse_char_set_content(counter$2, _ae_, end_ind) /*<>*/ ; + } + } + /*<>*/ if(37 === c) + /*<>*/ fail_single_percent(str_ind); + /*<>*/ add_in_char_set(char_set, c); + var str_ind$0 = /*<>*/ str_ind + 1 | 0; + str_ind = str_ind$0; + c = c$0; + } + var str_ind$1 = /*<>*/ str_ind + 1 | 0; + /*<>*/ if(str_ind$1 === end_ind) + /*<>*/ invalid_format_message + (end_ind, cst_unexpected_end_of_format); + var + c$1 = + /*<>*/ caml_string_get + (str, str_ind$1); + /*<>*/ if(37 === c$1){ + /*<>*/ if + ((str_ind$1 + 1 | 0) === end_ind) + /*<>*/ invalid_format_message + (end_ind, cst_unexpected_end_of_format); + var + c$2 = + /*<>*/ caml_string_get + (str, str_ind$1 + 1 | 0); + /*<>*/ if(37 !== c$2 && 64 !== c$2) + /*<>*/ return fail_single_percent + (str_ind$1) /*<>*/ ; + /*<>*/ add_range(c, c$2); + var _af_ = /*<>*/ str_ind$1 + 2 | 0; + if(counter >= 50) + return caml_trampoline_return + (parse_char_set_content, [0, _af_, end_ind]) /*<>*/ ; + var counter$1 = /*<>*/ counter + 1 | 0; + return parse_char_set_content(counter$1, _af_, end_ind) /*<>*/ ; + } + /*<>*/ if(93 === c$1){ + /*<>*/ add_in_char_set(char_set, c); + add_in_char_set(char_set, 45); + /*<>*/ return str_ind$1 + 1 | 0; + } + /*<>*/ add_range(c, c$1); + var _ag_ = /*<>*/ str_ind$1 + 1 | 0; + if(counter >= 50) + return caml_trampoline_return + (parse_char_set_content, [0, _ag_, end_ind]) /*<>*/ ; + var counter$0 = /*<>*/ counter + 1 | 0; + return parse_char_set_content(counter$0, _ag_, end_ind) /*<>*/ ; + } + function parse_char_set_after_char(str_ind, end_ind, c){ + /*<>*/ return /*<>*/ caml_trampoline + ( /*<>*/ parse_char_set_after_char$0 + (0, str_ind, end_ind, c)) /*<>*/ ; + } + /*<>*/ if(str_ind === end_ind) + /*<>*/ invalid_format_message + (end_ind, cst_unexpected_end_of_format); + /*<>*/ if + (94 === caml_string_get(str, str_ind)) + var + str_ind$0 = /*<>*/ str_ind + 1 | 0, + reverse = /*<>*/ 1, + str_ind$1 = str_ind$0; + else + var + reverse = /*<>*/ 0, + str_ind$1 = str_ind; + /*<>*/ if(str_ind$1 === end_ind) + /*<>*/ invalid_format_message + (end_ind, cst_unexpected_end_of_format); + var + c = + /*<>*/ caml_string_get(str, str_ind$1), + next_ind = + /*<>*/ parse_char_set_after_char + (str_ind$1 + 1 | 0, end_ind, c), + char_set$0 = + /*<>*/ freeze_char_set(char_set), + _ad_ = + /*<>*/ reverse + ? /*<>*/ rev_char_set(char_set$0) + : char_set$0; + /*<>*/ return [0, next_ind, _ad_]; + /*<>*/ } function parse_spaces(str_ind$1, end_ind){ var str_ind = /*<>*/ str_ind$1; for(;;){ @@ -26118,6 +26034,30 @@ }, t[1]) /*<>*/ ; } + function iter_weak(f, t){ + var i = /*<>*/ 0; + /*<>*/ return caml_call2 + (Stdlib_Array[13], + function(j, b){ + var i$0 = /*<>*/ i; + for(;;){ + /*<>*/ if(length(b) <= i$0) + /*<>*/ return 0; + /*<>*/ if(check(b, i$0)){ + /*<>*/ /*<>*/ caml_call3 + (f, + b, + /*<>*/ caml_check_bound(t[2], j)[1 + j], + i$0); + var i$1 = /*<>*/ i$0 + 1 | 0; + i$0 = i$1; + } + else{var i$2 = /*<>*/ i$0 + 1 | 0; i$0 = i$2; + } + } + }, + t[1]) /*<>*/ ; + } function count_bucket(i$1, b, accu$1){ var i = /*<>*/ i$1, accu = accu$1; for(;;){ @@ -26140,112 +26080,7 @@ t[1], 0) /*<>*/ ; } - function add_aux(t, setter, d, h, index){ - var - bucket$0 = - /*<>*/ caml_check_bound(t[1], index)[1 + index], - hashes = - /*<>*/ caml_check_bound(t[2], index)[1 + index], - sz = /*<>*/ length(bucket$0), - i$3 = /*<>*/ 0; - for(;;){ - /*<>*/ if(sz <= i$3) break; - /*<>*/ if(! check(bucket$0, i$3)){ - /*<>*/ caml_call3(setter, bucket$0, i$3, d); - /*<>*/ caml_check_bound(hashes, i$3)[1 + i$3] = h; - /*<>*/ return 0; - } - var i$5 = /*<>*/ i$3 + 1 | 0; - i$3 = i$5; - } - var - newsz = - /*<>*/ caml_call2 - (Stdlib_Int[10], - ((3 * sz | 0) / 2 | 0) + 3 | 0, - Stdlib_Sys[13] - 2 | 0); - /*<>*/ if(newsz <= sz) - /*<>*/ caml_call1 - (Stdlib[2], cst_Weak_Make_hash_bucket_cann); - var - newbucket$0 = /*<>*/ create(newsz), - newhashes = /*<>*/ caml_array_make(newsz, 0); - /*<>*/ blit(bucket$0, 0, newbucket$0, 0, sz); - /*<>*/ caml_call5 - (Stdlib_Array[9], hashes, 0, newhashes, 0, sz); - /*<>*/ caml_call3(setter, newbucket$0, sz, d); - /*<>*/ caml_check_bound(newhashes, sz)[1 + sz] = h; - /*<>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0; - /*<>*/ caml_check_bound(t[2], index)[1 + index] = newhashes; - var - _r_ = /*<>*/ sz <= t[3] ? 1 : 0, - _s_ = _r_ ? t[3] < newsz ? 1 : 0 : _r_; - if(_s_){ - /*<>*/ t[4] = t[4] + 1 | 0; - var i$4 = /*<>*/ 0; - for(;;){ - var - _h_ = /*<>*/ t[5], - bucket = /*<>*/ caml_check_bound(t[1], _h_)[1 + _h_], - _i_ = /*<>*/ t[5], - hbucket = /*<>*/ caml_check_bound(t[2], _i_)[1 + _i_], - len = /*<>*/ length(bucket), - prev_len = - /*<>*/ (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0, - live = /*<>*/ count_bucket(0, bucket, 0); - /*<>*/ if(live <= prev_len){ - var - i$0 = /*<>*/ 0, - j = /*<>*/ length(bucket) - 1 | 0; - /*<>*/ for(;;){ - /*<>*/ if(prev_len > j) break; - /*<>*/ if(check(bucket, i$0)){ - var i$1 = /*<>*/ i$0 + 1 | 0; - i$0 = i$1; - } - else if( /*<>*/ check(bucket, j)){ - /*<>*/ blit(bucket, j, bucket, i$0, 1); - var - _j_ = /*<>*/ caml_check_bound(hbucket, j)[1 + j]; - /*<>*/ caml_check_bound(hbucket, i$0)[1 + i$0] = _j_; - var j$0 = /*<>*/ j - 1 | 0, i$2 = i$0 + 1 | 0; - i$0 = i$2; - j = j$0; - } - else{var j$1 = /*<>*/ j - 1 | 0; j = j$1;} - } - /*<>*/ if(0 === prev_len){ - var _k_ = /*<>*/ t[5]; - /*<>*/ caml_check_bound(t[1], _k_)[1 + _k_] = emptybucket; - var _l_ = /*<>*/ t[5]; - /*<>*/ caml_check_bound(t[2], _l_)[1 + _l_] = [0]; - } - else{ - var newbucket = /*<>*/ create(prev_len); - /*<>*/ blit(bucket, 0, newbucket, 0, prev_len); - var _o_ = /*<>*/ t[5]; - /*<>*/ caml_check_bound(t[1], _o_)[1 + _o_] = newbucket; - var - _p_ = - /*<>*/ caml_call3 - (Stdlib_Array[6], hbucket, 0, prev_len), - _q_ = /*<>*/ t[5]; - /*<>*/ caml_check_bound(t[2], _q_)[1 + _q_] = _p_; - } - var - _m_ = /*<>*/ t[3] < len ? 1 : 0, - _n_ = _m_ ? prev_len <= t[3] ? 1 : 0 : _m_; - if(_n_) /*<>*/ t[4] = t[4] - 1 | 0; - } - /*<>*/ t[5] = caml_mod(t[5] + 1 | 0, t[1].length - 1); - var _u_ = /*<>*/ i$4 + 1 | 0; - if(2 === i$4) break; - i$4 = _u_; - } - } - var - _t_ = /*<>*/ ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0; - if(! _t_) return _t_; + function resize(t){ var oldlen = /*<>*/ t[1].length - 1, newlen = @@ -26254,32 +26089,20 @@ /*<>*/ if(oldlen < newlen){ var newt = /*<>*/ create$0(newlen), - i = /*<>*/ 0; - /*<>*/ caml_call2 - (Stdlib_Array[13], - function(j, ob){ - var oi = /*<>*/ i; - for(;;){ - /*<>*/ if(length(ob) <= oi) - /*<>*/ return 0; - /*<>*/ if(check(ob, oi)){ - var oh = /*<>*/ caml_check_bound(t[2], j)[1 + j]; - let oi$0 = /*<>*/ oi; - var - setter = - function(nb, ni, param){ - /*<>*/ return blit(ob, oi$0, nb, ni, 1) /*<>*/ ; - }, - h = /*<>*/ caml_check_bound(oh, oi)[1 + oi]; - /*<>*/ /*<>*/ add_aux - (newt, setter, 0, h, /*<>*/ get_index(newt, h)); - var i$0 = /*<>*/ oi + 1 | 0; - oi = i$0; + add_weak = + /*<>*/ function(ob, oh, oi){ + function setter(nb, ni, param){ + /*<>*/ return blit(ob, oi, nb, ni, 1) /*<>*/ ; } - else{var i$1 = /*<>*/ oi + 1 | 0; oi = i$1;} - } - }, - t[1]); + var h = /*<>*/ caml_check_bound(oh, oi)[1 + oi]; + /*<>*/ return /*<>*/ add_aux + (newt, + setter, + 0, + h, + /*<>*/ get_index(newt, h)) /*<>*/ ; + }; + /*<>*/ iter_weak(add_weak, t); /*<>*/ t[1] = newt[1]; /*<>*/ t[2] = newt[2]; /*<>*/ t[3] = newt[3]; @@ -26290,7 +26113,123 @@ /*<>*/ t[3] = Stdlib[19]; /*<>*/ t[4] = 0; return 0; - /*<>*/ } + /*<>*/ } + function add_aux(t, setter, d, h, index){ + var + bucket = + /*<>*/ caml_check_bound(t[1], index)[1 + index], + hashes = + /*<>*/ caml_check_bound(t[2], index)[1 + index], + sz = /*<>*/ length(bucket); + function loop(i$2){ + var i$3 = /*<>*/ i$2; + for(;;){ + if(sz <= i$3){ + var + newsz = + /*<>*/ caml_call2 + (Stdlib_Int[10], + ((3 * sz | 0) / 2 | 0) + 3 | 0, + Stdlib_Sys[13] - 2 | 0); + /*<>*/ if(newsz <= sz) + /*<>*/ caml_call1 + (Stdlib[2], cst_Weak_Make_hash_bucket_cann); + var + newbucket$0 = /*<>*/ create(newsz), + newhashes = /*<>*/ caml_array_make(newsz, 0); + /*<>*/ blit(bucket, 0, newbucket$0, 0, sz); + /*<>*/ caml_call5 + (Stdlib_Array[9], hashes, 0, newhashes, 0, sz); + /*<>*/ caml_call3(setter, newbucket$0, sz, d); + /*<>*/ caml_check_bound(newhashes, sz)[1 + sz] = h; + /*<>*/ caml_check_bound(t[1], index)[1 + index] = newbucket$0; + /*<>*/ caml_check_bound(t[2], index)[1 + index] = newhashes; + var + _r_ = /*<>*/ sz <= t[3] ? 1 : 0, + _s_ = _r_ ? t[3] < newsz ? 1 : 0 : _r_; + if(_s_){ + /*<>*/ t[4] = t[4] + 1 | 0; + var i$4 = /*<>*/ 0; + for(;;){ + var + _h_ = /*<>*/ t[5], + bucket$0 = + /*<>*/ caml_check_bound(t[1], _h_)[1 + _h_], + _i_ = /*<>*/ t[5], + hbucket = + /*<>*/ caml_check_bound(t[2], _i_)[1 + _i_], + len = /*<>*/ length(bucket$0), + prev_len = + /*<>*/ (((len - 3 | 0) * 2 | 0) + 2 | 0) / 3 | 0, + live = /*<>*/ count_bucket(0, bucket$0, 0); + /*<>*/ if(live <= prev_len){ + var + i = /*<>*/ 0, + j = /*<>*/ length(bucket$0) - 1 | 0; + /*<>*/ for(;;){ + /*<>*/ if(prev_len > j) break; + /*<>*/ if(check(bucket$0, i)){ + var i$0 = /*<>*/ i + 1 | 0; + i = i$0; + } + else if( /*<>*/ check(bucket$0, j)){ + /*<>*/ blit(bucket$0, j, bucket$0, i, 1); + var + _j_ = + /*<>*/ caml_check_bound(hbucket, j)[1 + j]; + /*<>*/ caml_check_bound(hbucket, i)[1 + i] = _j_; + var j$0 = /*<>*/ j - 1 | 0, i$1 = i + 1 | 0; + i = i$1; + j = j$0; + } + else{var j$1 = /*<>*/ j - 1 | 0; j = j$1;} + } + /*<>*/ if(0 === prev_len){ + var _k_ = /*<>*/ t[5]; + /*<>*/ caml_check_bound(t[1], _k_)[1 + _k_] = emptybucket; + var _l_ = /*<>*/ t[5]; + /*<>*/ caml_check_bound(t[2], _l_)[1 + _l_] = [0]; + } + else{ + var newbucket = /*<>*/ create(prev_len); + /*<>*/ blit(bucket$0, 0, newbucket, 0, prev_len); + var _o_ = /*<>*/ t[5]; + /*<>*/ caml_check_bound(t[1], _o_)[1 + _o_] = newbucket; + var + _p_ = + /*<>*/ caml_call3 + (Stdlib_Array[6], hbucket, 0, prev_len), + _q_ = /*<>*/ t[5]; + /*<>*/ caml_check_bound(t[2], _q_)[1 + _q_] = _p_; + } + var + _m_ = /*<>*/ t[3] < len ? 1 : 0, + _n_ = _m_ ? prev_len <= t[3] ? 1 : 0 : _m_; + if(_n_) /*<>*/ t[4] = t[4] - 1 | 0; + } + /*<>*/ t[5] = + caml_mod(t[5] + 1 | 0, t[1].length - 1); + var _u_ = /*<>*/ i$4 + 1 | 0; + if(2 === i$4) break; + i$4 = _u_; + } + } + var + _t_ = + /*<>*/ ((t[1].length - 1) / 2 | 0) < t[4] ? 1 : 0; + return _t_ ? /*<>*/ resize(t) : _t_ /*<>*/ ; + } + /*<>*/ if(! check(bucket, i$3)){ + /*<>*/ caml_call3(setter, bucket, i$3, d); + /*<>*/ caml_check_bound(hashes, i$3)[1 + i$3] = h; + /*<>*/ return 0; + } + var i$5 = /*<>*/ i$3 + 1 | 0; + i$3 = i$5; + } + /*<>*/ } + /*<>*/ return loop(0) /*<>*/ ; + } function add(t, d){ var h = /*<>*/ caml_call1(H[2], d); /*<>*/ return /*<>*/ add_aux @@ -27239,7 +27178,7 @@ /*<>*/ return [0, state[8], state[6]]; /*<>*/ } function pp_update_geometry(state, update){ - var geometry = /*<>*/ pp_get_geometry(state, 0); + var geometry = /*<>*/ [0, state[8], state[6]]; /*<>*/ return /*<>*/ pp_set_full_geometry (state, /*<>*/ caml_call1(update, geometry)) /*<>*/ ; } @@ -27887,11 +27826,12 @@ margin) /*<>*/ ; } function get_geometry(v){ - /*<>*/ return /*<>*/ pp_get_geometry - ( /*<>*/ caml_call1 - (Stdlib_Domain[11][2], std_formatter_key), - v) /*<>*/ ; - } + var + state = + /*<>*/ caml_call1 + (Stdlib_Domain[11][2], std_formatter_key); + /*<>*/ return [0, state[8], state[6]]; + /*<>*/ } function update_geometry(v){ /*<>*/ return /*<>*/ pp_update_geometry ( /*<>*/ caml_call1 @@ -27943,11 +27883,17 @@ v) /*<>*/ ; } function get_formatter_out_functions(v){ - /*<>*/ return /*<>*/ pp_get_formatter_out_functions - ( /*<>*/ caml_call1 - (Stdlib_Domain[11][2], std_formatter_key), - v) /*<>*/ ; - } + var + state = + /*<>*/ caml_call1 + (Stdlib_Domain[11][2], std_formatter_key); + /*<>*/ return [0, + state[17], + state[18], + state[19], + state[20], + state[21]]; + /*<>*/ } function set_formatter_output_functions(v, w){ /*<>*/ return /*<>*/ pp_set_formatter_output_functi ( /*<>*/ caml_call1 @@ -27956,11 +27902,12 @@ w) /*<>*/ ; } function get_formatter_output_functions(v){ - /*<>*/ return /*<>*/ pp_get_formatter_output_functi - ( /*<>*/ caml_call1 - (Stdlib_Domain[11][2], std_formatter_key), - v) /*<>*/ ; - } + var + state = + /*<>*/ caml_call1 + (Stdlib_Domain[11][2], std_formatter_key); + /*<>*/ return [0, state[17], state[18]]; + /*<>*/ } function set_formatter_stag_functions(v){ /*<>*/ return /*<>*/ pp_set_formatter_stag_function ( /*<>*/ caml_call1 @@ -27968,11 +27915,16 @@ v) /*<>*/ ; } function get_formatter_stag_functions(v){ - /*<>*/ return /*<>*/ pp_get_formatter_stag_function - ( /*<>*/ caml_call1 - (Stdlib_Domain[11][2], std_formatter_key), - v) /*<>*/ ; - } + var + state = + /*<>*/ caml_call1 + (Stdlib_Domain[11][2], std_formatter_key); + /*<>*/ return [0, + state[24], + state[25], + state[26], + state[27]]; + /*<>*/ } function set_print_tags(v){ /*<>*/ return /*<>*/ pp_set_print_tags ( /*<>*/ caml_call1 @@ -28487,11 +28439,7 @@ (Stdlib_Domain[5], function(param){ /*<>*/ flush_standard_formatters(0); - var - fs = - /*<>*/ pp_get_formatter_out_functions - (std_formatter, 0), - _h_ = /*<>*/ Stdlib[39]; + var _h_ = /*<>*/ Stdlib[39]; /*<>*/ pp_set_formatter_out_functions (std_formatter, [0, @@ -28503,14 +28451,10 @@ /*<>*/ return buffered_out_flush (_h_, std_buf_key, _n_); }, - fs[3], - fs[4], - fs[5]]); - var - fs$0 = - /*<>*/ pp_get_formatter_out_functions - (err_formatter, 0), - _i_ = /*<>*/ Stdlib[40]; + std_formatter[19], + std_formatter[20], + std_formatter[21]]); + var _i_ = /*<>*/ Stdlib[40]; /*<>*/ return pp_set_formatter_out_functions (err_formatter, [0, @@ -28522,9 +28466,9 @@ /*<>*/ return buffered_out_flush (_i_, err_buf_key, _j_); }, - fs$0[3], - fs$0[4], - fs$0[5]]) /*<>*/ ; + err_formatter[19], + err_formatter[20], + err_formatter[21]]) /*<>*/ ; }); var Stdlib_Format = @@ -28829,18 +28773,6 @@ /*<>*/ return ignore_char(width, ib) /*<>*/ ; } var default_token_buffer_size = /*<>*/ 1024; - function create(iname, next){ - /*<>*/ return [0, - 0, - null_char, - 0, - 0, - 0, - 0, - next, - caml_call1(Stdlib_Buffer[1], default_token_buffer_size), - iname] /*<>*/ ; - /*<>*/ } function from_string(s){ var i = /*<>*/ [0, 0], @@ -28853,10 +28785,30 @@ /*<>*/ i[1]++; /*<>*/ return c; /*<>*/ } - /*<>*/ return create(1, next) /*<>*/ ; + /*<>*/ return [0, + 0, + null_char, + 0, + 0, + 0, + 0, + next, + caml_call1(Stdlib_Buffer[1], default_token_buffer_size), + 1] /*<>*/ ; + /*<>*/ } + var iname = /*<>*/ 0; + function from_function(next){ + /*<>*/ return [0, + 0, + null_char, + 0, + 0, + 0, + 0, + next, + caml_call1(Stdlib_Buffer[1], default_token_buffer_size), + iname] /*<>*/ ; } - var _a_ = /*<>*/ 0; - function from_function(_aW_){return create(_a_, _aW_);} var len = /*<>*/ 1024; function scan_close_at_end(ic){ /*<>*/ caml_call1(Stdlib[93], ic); @@ -28888,8 +28840,17 @@ /*<>*/ caml_call1(scan_close_ic, ic)) : (i[1] = 1, /*<>*/ caml_bytes_get(buf, 0)) /*<>*/ ; } - /*<>*/ return create(iname, next) /*<>*/ ; - } + /*<>*/ return [0, + 0, + null_char, + 0, + 0, + 0, + 0, + next, + caml_call1(Stdlib_Buffer[1], default_token_buffer_size), + iname] /*<>*/ ; + /*<>*/ } var stdin = /*<>*/ from_ic @@ -28901,11 +28862,11 @@ /*<>*/ return from_ic (scan_close_at_end, [1, fname, ic], ic) /*<>*/ ; } - var _b_ = /*<>*/ Stdlib[79]; - function open_in(_aV_){return open_in_file(_b_, _aV_);} - var _c_ = /*<>*/ Stdlib[80]; - function open_in_bin(_aU_){ - /*<>*/ return open_in_file(_c_, _aU_); + var _a_ = /*<>*/ Stdlib[79]; + function open_in(_aU_){return open_in_file(_a_, _aU_);} + var _b_ = /*<>*/ Stdlib[80]; + function open_in_bin(_aT_){ + /*<>*/ return open_in_file(_b_, _aT_); } function from_channel(ic){ /*<>*/ return from_ic(scan_raise_at_end, [0, ic], ic) /*<>*/ ; @@ -28925,11 +28886,11 @@ /*<>*/ [248, "Stdlib.Scanf.Scan_failure", runtime.caml_fresh_oo_id(0)], - _d_ = + _c_ = /*<>*/ [0, [11, "illegal escape character ", [1, 0]], "illegal escape character %C"], - _e_ = + _d_ = [0, [11, cst_scanning_of, @@ -28937,7 +28898,7 @@ 0, [11, " failed: the specified length was too short for token", 0]]], "scanning of %s failed: the specified length was too short for token"], - _f_ = + _e_ = [0, [11, cst_scanning_of, @@ -28947,26 +28908,26 @@ " failed: premature end of file occurred before end of token", 0]]], "scanning of %s failed: premature end of file occurred before end of token"], - _g_ = + _f_ = [0, [11, "looking for ", [1, [11, ", found ", [1, 0]]]], "looking for %C, found %C"], - _h_ = + _g_ = [0, [11, "invalid boolean '", [2, 0, [12, 39, 0]]], "invalid boolean '%s'"], - _i_ = [0, cst_scanf_ml, 516, 9], + _h_ = [0, cst_scanf_ml, 516, 9], cst_0b = "0b", cst_0o = "0o", cst_0u = "0u", cst_0x = "0x", cst_decimal_digits = "decimal digits", - _j_ = + _i_ = [0, [11, cst_character, [1, [11, " is not a decimal digit", 0]]], "character %C is not a decimal digit"], cst_digits = "digits", - _k_ = + _j_ = [0, [11, cst_character, @@ -28975,32 +28936,32 @@ cst_an = "an", cst_nfinity = "nfinity", cst_x = "x", - _l_ = + _k_ = [0, [11, "bad character decimal encoding \\", [0, [0, [0, 0]]]], "bad character decimal encoding \\%c%c%c"], - _m_ = + _l_ = [0, [11, "bad character hexadecimal encoding \\", [0, [0, 0]]], "bad character hexadecimal encoding \\%c%c"], - _n_ = + _m_ = [0, [11, "the character ", [1, [11, " cannot start a boolean", 0]]], "the character %C cannot start a boolean"], - _o_ = + _n_ = [0, [11, "scanf: bad input at char number ", [4, 3, 0, 0, [11, ": ", [2, 0, 0]]]], "scanf: bad input at char number %i: %s"], - _p_ = [0, 37, ""], - _q_ = [0, 123], - _r_ = [0, 91], + _o_ = [0, 37, ""], + _p_ = [0, 123], + _q_ = [0, 91], cst_end_of_input_not_found = "end of input not found", cst_scanf_bad_conversion_a = 'scanf: bad conversion "%a"', cst_scanf_bad_conversion_t = 'scanf: bad conversion "%t"', cst_scanf_missing_reader = "scanf: missing reader", - _s_ = [0, cst_scanf_ml, 1414, 13], + _r_ = [0, cst_scanf_ml, 1414, 13], cst_scanf_bad_conversion_custo = 'scanf: bad conversion "%?" (custom converter)', cst_scanf_bad_conversion = cst_scanf_bad_conversion$3, @@ -29008,26 +28969,26 @@ cst_scanf_bad_conversion$1 = 'scanf: bad conversion "%-"', cst_scanf_bad_conversion$2 = cst_scanf_bad_conversion$3, cst_in_format = ' in format "', - _t_ = [0, [3, 0, [10, 0]], "%S%!"]; + _s_ = [0, [3, 0, [10, 0]], "%S%!"]; function bad_input(s){ /*<>*/ throw caml_maybe_attach_backtrace ([0, Scan_failure, s], 1); /*<>*/ } function bad_input_escape(c){ /*<>*/ return /*<>*/ bad_input - ( /*<>*/ caml_call2(Stdlib_Printf[4], _d_, c)) /*<>*/ ; + ( /*<>*/ caml_call2(Stdlib_Printf[4], _c_, c)) /*<>*/ ; } function bad_token_length(message){ /*<>*/ return /*<>*/ bad_input ( /*<>*/ caml_call2 - (Stdlib_Printf[4], _e_, message)) /*<>*/ ; + (Stdlib_Printf[4], _d_, message)) /*<>*/ ; } function bad_hex_float(param){ /*<>*/ return bad_input(cst_not_a_valid_float_in_hexad) /*<>*/ ; } function character_mismatch(c, ci){ /*<>*/ return /*<>*/ bad_input - ( /*<>*/ caml_call3(Stdlib_Printf[4], _g_, c, ci)) /*<>*/ ; + ( /*<>*/ caml_call3(Stdlib_Printf[4], _f_, c, ci)) /*<>*/ ; } function check_char(ib, c$0){ /*<>*/ if(10 === c$0){ @@ -29046,15 +29007,15 @@ /*<>*/ for(;;){ var c = /*<>*/ peek_char(ib), - _aS_ = /*<>*/ 1 - ib[1]; - if(! _aS_) return _aS_; - var _aT_ = /*<>*/ c - 9 | 0; + _aR_ = /*<>*/ 1 - ib[1]; + if(! _aR_) return _aR_; + var _aS_ = /*<>*/ c - 9 | 0; a: { - if(4 < _aT_ >>> 0){ - if(23 !== _aT_) break a; + if(4 < _aS_ >>> 0){ + if(23 !== _aS_) break a; } - else if(1 >= _aT_ - 2 >>> 0) break a; + else if(1 >= _aS_ - 2 >>> 0) break a; /*<>*/ invalidate_current_char(ib); continue; } @@ -29076,7 +29037,7 @@ ? s !== "true" ? /*<>*/ bad_input - ( /*<>*/ caml_call2(Stdlib_Printf[4], _h_, s)) + ( /*<>*/ caml_call2(Stdlib_Printf[4], _g_, s)) : 1 : 0 /*<>*/ ; } @@ -29099,37 +29060,37 @@ /*<>*/ return 5; } /*<>*/ throw caml_maybe_attach_backtrace - ([0, Assert_failure, _i_], 1); + ([0, Assert_failure, _h_], 1); /*<>*/ } function token_int_literal(conv, ib){ /*<>*/ switch(conv){ case 0: var - _aO_ = /*<>*/ token_string(ib), + _aN_ = /*<>*/ token_string(ib), tok = /*<>*/ /*<>*/ caml_call2 - (Stdlib[28], cst_0b, _aO_); + (Stdlib[28], cst_0b, _aN_); break; case 3: var - _aP_ = /*<>*/ token_string(ib), + _aO_ = /*<>*/ token_string(ib), tok = /*<>*/ /*<>*/ caml_call2 - (Stdlib[28], cst_0o, _aP_); + (Stdlib[28], cst_0o, _aO_); break; case 4: var - _aQ_ = /*<>*/ token_string(ib), + _aP_ = /*<>*/ token_string(ib), tok = /*<>*/ /*<>*/ caml_call2 - (Stdlib[28], cst_0u, _aQ_); + (Stdlib[28], cst_0u, _aP_); break; case 5: var - _aR_ = /*<>*/ token_string(ib), + _aQ_ = /*<>*/ token_string(ib), tok = /*<>*/ /*<>*/ caml_call2 - (Stdlib[28], cst_0x, _aR_); + (Stdlib[28], cst_0x, _aQ_); break; default: var @@ -29174,7 +29135,7 @@ var c = /*<>*/ checked_peek_char(ib); /*<>*/ if(9 < c - 48 >>> 0) /*<>*/ return /*<>*/ bad_input - ( /*<>*/ caml_call2(Stdlib_Printf[4], _j_, c)) /*<>*/ ; + ( /*<>*/ caml_call2(Stdlib_Printf[4], _i_, c)) /*<>*/ ; var width$0 = /*<>*/ store_char(width, ib, c); /*<>*/ return scan_decimal_digit_star(width$0, ib) /*<>*/ ; } @@ -29185,7 +29146,7 @@ /*<>*/ if(! caml_call1(digitp, c$0)) /*<>*/ return /*<>*/ bad_input ( /*<>*/ caml_call3 - (Stdlib_Printf[4], _k_, c$0, basis)) /*<>*/ ; + (Stdlib_Printf[4], _j_, c$0, basis)) /*<>*/ ; var width$3 = /*<>*/ store_char(width$2, ib, c$0), width = /*<>*/ width$3; @@ -29213,13 +29174,13 @@ /*<>*/ return 7 < param - 48 >>> 0 ? 0 : 1 /*<>*/ ; } function is_hexa_digit(param){ - var _aN_ = /*<>*/ param - 48 | 0; + var _aM_ = /*<>*/ param - 48 | 0; a: { - if(22 < _aN_ >>> 0){ - if(5 < _aN_ - 49 >>> 0) break a; + if(22 < _aM_ >>> 0){ + if(5 < _aM_ - 49 >>> 0) break a; } - else if(6 >= _aN_ - 10 >>> 0) break a; + else if(6 >= _aM_ - 10 >>> 0) break a; /*<>*/ return 1; } /*<>*/ return 0; @@ -29355,39 +29316,39 @@ var len = /*<>*/ caml_ml_string_length(str), width$0 = /*<>*/ [0, width], - _aK_ = /*<>*/ len - 1 | 0, - _aJ_ = 0; - if(_aK_ >= 0){ - var i = _aJ_; + _aJ_ = /*<>*/ len - 1 | 0, + _aI_ = 0; + if(_aJ_ >= 0){ + var i = _aI_; for(;;){ var c = /*<>*/ peek_char(ib), - _aL_ = + _aK_ = /*<>*/ /*<>*/ lowercase ( /*<>*/ caml_string_get(str, i)); - /*<>*/ if(lowercase(c) !== _aL_) + /*<>*/ if(lowercase(c) !== _aK_) /*<>*/ caml_call1(error, 0); /*<>*/ if(0 === width$0[1]) /*<>*/ caml_call1(error, 0); /*<>*/ width$0[1] = store_char(width$0[1], ib, c); - var _aM_ = /*<>*/ i + 1 | 0; - if(_aK_ === i) break; - i = _aM_; + var _aL_ = /*<>*/ i + 1 | 0; + if(_aJ_ === i) break; + i = _aL_; } } /*<>*/ return width$0[1]; /*<>*/ } function scan_hex_float(width, precision, ib){ var - _aw_ = /*<>*/ 0 === width ? 1 : 0, - _ax_ = _aw_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_ax_) + _av_ = /*<>*/ 0 === width ? 1 : 0, + _aw_ = _av_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_aw_) /*<>*/ bad_input(cst_not_a_valid_float_in_hexad); var width$0 = /*<>*/ scan_sign(width, ib), - _ay_ = /*<>*/ 0 === width$0 ? 1 : 0, - _az_ = _ay_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_az_) + _ax_ = /*<>*/ 0 === width$0 ? 1 : 0, + _ay_ = _ax_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_ay_) /*<>*/ bad_input(cst_not_a_valid_float_in_hexad); var c = /*<>*/ peek_char(ib); a: @@ -29398,9 +29359,9 @@ if(32 <= switcher) break a; var width$1 = /*<>*/ store_char(width$0, ib, c), - _aA_ = /*<>*/ 0 === width$1 ? 1 : 0, - _aB_ = _aA_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_aB_) + _az_ = /*<>*/ 0 === width$1 ? 1 : 0, + _aA_ = _az_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_aA_) /*<>*/ bad_input(cst_not_a_valid_float_in_hexad); /*<>*/ return check_case_insensitive_string (width$1, ib, bad_hex_float, cst_an) /*<>*/ ; @@ -29411,9 +29372,9 @@ if(48 === c){ var width$3 = /*<>*/ store_char(width$0, ib, c), - _aE_ = /*<>*/ 0 === width$3 ? 1 : 0, - _aF_ = _aE_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_aF_) + _aD_ = /*<>*/ 0 === width$3 ? 1 : 0, + _aE_ = _aD_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_aE_) /*<>*/ bad_input(cst_not_a_valid_float_in_hexad); var width$4 = @@ -29421,13 +29382,13 @@ (width$3, ib, bad_hex_float, cst_x); /*<>*/ if (0 !== width$4 && ! /*<>*/ end_of_input(ib)){ - var _aG_ = /*<>*/ peek_char(ib) - 46 | 0; + var _aF_ = /*<>*/ peek_char(ib) - 46 | 0; b: { - /*<>*/ if(34 < _aG_ >>> 0){ - if(66 === _aG_){var width$5 = width$4; break b;} + /*<>*/ if(34 < _aF_ >>> 0){ + if(66 === _aF_){var width$5 = width$4; break b;} } - else if(32 < _aG_ - 1 >>> 0){var width$5 = width$4; break b;} + else if(32 < _aF_ - 1 >>> 0){var width$5 = width$4; break b;} var width$5 = /*<>*/ scan_digit_plus @@ -29471,9 +29432,9 @@ /*<>*/ return width$7; var width$8 = /*<>*/ store_char(width$7, ib, c$1), - _aH_ = /*<>*/ 0 === width$8 ? 1 : 0, - _aI_ = _aH_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_aI_) + _aG_ = /*<>*/ 0 === width$8 ? 1 : 0, + _aH_ = _aG_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_aH_) /*<>*/ bad_input(cst_not_a_valid_float_in_hexad); /*<>*/ return scan_optionally_signed_decimal (width$8, ib) /*<>*/ ; @@ -29488,9 +29449,9 @@ } var width$2 = /*<>*/ store_char(width$0, ib, c), - _aC_ = /*<>*/ 0 === width$2 ? 1 : 0, - _aD_ = _aC_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_aD_) + _aB_ = /*<>*/ 0 === width$2 ? 1 : 0, + _aC_ = _aB_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_aC_) /*<>*/ bad_input(cst_not_a_valid_float_in_hexad); /*<>*/ return check_case_insensitive_string (width$2, ib, bad_hex_float, cst_nfinity) /*<>*/ ; @@ -29499,15 +29460,15 @@ } function scan_caml_float_rest(width, precision, ib){ var - _as_ = /*<>*/ 0 === width ? 1 : 0, - _at_ = _as_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_at_) + _ar_ = /*<>*/ 0 === width ? 1 : 0, + _as_ = _ar_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_as_) /*<>*/ bad_input(cst_no_dot_or_exponent_part_fo); var width$0 = /*<>*/ scan_decimal_digit_star(width, ib), - _au_ = /*<>*/ 0 === width$0 ? 1 : 0, - _av_ = _au_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_av_) + _at_ = /*<>*/ 0 === width$0 ? 1 : 0, + _au_ = _at_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_au_) /*<>*/ bad_input(cst_no_dot_or_exponent_part_fo); var c = /*<>*/ peek_char(ib), @@ -29532,24 +29493,24 @@ } function scan_caml_float(width, precision, ib){ var - _ae_ = /*<>*/ 0 === width ? 1 : 0, - _af_ = _ae_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_af_) + _ad_ = /*<>*/ 0 === width ? 1 : 0, + _ae_ = _ad_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_ae_) /*<>*/ bad_input(cst_no_dot_or_exponent_part_fo); var width$0 = /*<>*/ scan_sign(width, ib), - _ag_ = /*<>*/ 0 === width$0 ? 1 : 0, - _ah_ = _ag_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_ah_) + _af_ = /*<>*/ 0 === width$0 ? 1 : 0, + _ag_ = _af_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_ag_) /*<>*/ bad_input(cst_no_dot_or_exponent_part_fo); var c = /*<>*/ peek_char(ib); /*<>*/ if(49 <= c){ if(58 > c){ var width$1 = /*<>*/ store_char(width$0, ib, c), - _ai_ = /*<>*/ 0 === width$1 ? 1 : 0, - _aj_ = _ai_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_aj_) + _ah_ = /*<>*/ 0 === width$1 ? 1 : 0, + _ai_ = _ah_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_ai_) /*<>*/ bad_input(cst_no_dot_or_exponent_part_fo); /*<>*/ return scan_caml_float_rest (width$1, precision, ib) /*<>*/ ; @@ -29558,9 +29519,9 @@ else if(48 <= c){ var width$2 = /*<>*/ store_char(width$0, ib, c), - _ak_ = /*<>*/ 0 === width$2 ? 1 : 0, - _al_ = _ak_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_al_) + _aj_ = /*<>*/ 0 === width$2 ? 1 : 0, + _ak_ = _aj_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_ak_) /*<>*/ bad_input(cst_no_dot_or_exponent_part_fo); var c$0 = /*<>*/ peek_char(ib); /*<>*/ if(88 !== c$0 && 120 !== c$0) @@ -29568,17 +29529,17 @@ (width$2, precision, ib) /*<>*/ ; var width$3 = /*<>*/ store_char(width$2, ib, c$0), - _am_ = /*<>*/ 0 === width$3 ? 1 : 0, - _an_ = _am_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_an_) + _al_ = /*<>*/ 0 === width$3 ? 1 : 0, + _am_ = _al_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_am_) /*<>*/ bad_input(cst_no_dot_or_exponent_part_fo); var width$7 = /*<>*/ scan_digit_plus (cst_hexadecimal, is_hexa_digit, width$3, ib), - _ao_ = /*<>*/ 0 === width$7 ? 1 : 0, - _ap_ = _ao_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_ap_) + _an_ = /*<>*/ 0 === width$7 ? 1 : 0, + _ao_ = _an_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_ao_) /*<>*/ bad_input(cst_no_dot_or_exponent_part_fo); var c$1 = /*<>*/ peek_char(ib), @@ -29633,9 +29594,9 @@ /*<>*/ return width$5; var width$6 = /*<>*/ store_char(width$5, ib, c$2), - _aq_ = /*<>*/ 0 === width$6 ? 1 : 0, - _ar_ = _aq_ || /*<>*/ end_of_input(ib); - /*<>*/ if(_ar_) + _ap_ = /*<>*/ 0 === width$6 ? 1 : 0, + _aq_ = _ap_ || /*<>*/ end_of_input(ib); + /*<>*/ if(_aq_) /*<>*/ bad_input(cst_not_a_valid_float_in_hexad); /*<>*/ return scan_optionally_signed_decimal (width$6, ib) /*<>*/ ; @@ -29662,13 +29623,13 @@ /*<>*/ width$0 = width$1; } else{ - var _ad_ = /*<>*/ c - 9 | 0; + var _ac_ = /*<>*/ c - 9 | 0; a: { - if(4 < _ad_ >>> 0){ - if(23 !== _ad_) break a; + if(4 < _ac_ >>> 0){ + if(23 !== _ac_) break a; } - else if(1 >= _ad_ - 2 >>> 0) break a; + else if(1 >= _ac_ - 2 >>> 0) break a; /*<>*/ return width$0; } var width$2 = /*<>*/ store_char(width$0, ib, c); @@ -29688,7 +29649,7 @@ /*<>*/ return ib[1] ? /*<>*/ bad_input ( /*<>*/ caml_call2 - (Stdlib_Printf[4], _f_, message)) + (Stdlib_Printf[4], _e_, message)) : c /*<>*/ ; } function scan_backslash_char(width, ib){ @@ -29717,16 +29678,16 @@ b: { /*<>*/ if(0 <= c && 255 >= c){ - var _ab_ = /*<>*/ caml_call1(Stdlib[29], c); + var _aa_ = /*<>*/ caml_call1(Stdlib[29], c); break b; } var - _ab_ = + _aa_ = /*<>*/ bad_input ( /*<>*/ caml_call4 - (Stdlib_Printf[4], _l_, c0, c1$0, c2$0)); + (Stdlib_Printf[4], _k_, c0, c1$0, c2$0)); } - /*<>*/ return store_char(width - 2 | 0, ib, _ab_) /*<>*/ ; + /*<>*/ return store_char(width - 2 | 0, ib, _aa_) /*<>*/ ; } var switcher = /*<>*/ c0 - 92 | 0; if(28 < switcher >>> 0) break a; @@ -29737,37 +29698,37 @@ /*<>*/ function(param){ var c = /*<>*/ next_char(ib), - _ac_ = /*<>*/ c - 48 | 0; + _ab_ = /*<>*/ c - 48 | 0; a: { - if(22 < _ac_ >>> 0){ - if(5 < _ac_ - 49 >>> 0) break a; + if(22 < _ab_ >>> 0){ + if(5 < _ab_ - 49 >>> 0) break a; } - else if(6 >= _ac_ - 10 >>> 0) break a; + else if(6 >= _ab_ - 10 >>> 0) break a; /*<>*/ return c; } /*<>*/ return bad_input_escape(c) /*<>*/ ; }, c1 = /*<>*/ get_digit(0), c2 = /*<>*/ get_digit(0), - ___ = /*<>*/ hexadecimal_value_of_char(c2), + _Z_ = /*<>*/ hexadecimal_value_of_char(c2), c$0 = /*<>*/ (16 * hexadecimal_value_of_char(c1) | 0) - + ___ + + _Z_ | 0; b: { /*<>*/ if(0 <= c$0 && 255 >= c$0){ - var _aa_ = /*<>*/ caml_call1(Stdlib[29], c$0); + var _$_ = /*<>*/ caml_call1(Stdlib[29], c$0); break b; } var - _aa_ = + _$_ = /*<>*/ bad_input ( /*<>*/ caml_call3 - (Stdlib_Printf[4], _m_, c1, c2)); + (Stdlib_Printf[4], _l_, c1, c2)); } - /*<>*/ return store_char(width - 2 | 0, ib, _aa_) /*<>*/ ; + /*<>*/ return store_char(width - 2 | 0, ib, _$_) /*<>*/ ; case 0: case 6: case 18: @@ -29779,20 +29740,20 @@ else if(34 !== c0 && 39 > c0) break a; /*<>*/ if(110 <= c0) if(117 <= c0) - var _$_ = c0; + var ___ = c0; else switch(c0 - 110 | 0){ case 0: - var _$_ = /*<>*/ 10; break; + var ___ = /*<>*/ 10; break; case 4: - var _$_ = /*<>*/ 13; break; + var ___ = /*<>*/ 13; break; case 6: - var _$_ = /*<>*/ 9; break; - default: var _$_ = /*<>*/ c0; + var ___ = /*<>*/ 9; break; + default: var ___ = /*<>*/ c0; } else - var _$_ = 98 === c0 ? 8 : c0; - /*<>*/ return store_char(width, ib, _$_) /*<>*/ ; + var ___ = 98 === c0 ? 8 : c0; + /*<>*/ return store_char(width, ib, ___) /*<>*/ ; } /*<>*/ return bad_input_escape(c0) /*<>*/ ; } @@ -29811,21 +29772,21 @@ match = /*<>*/ check_next_char(cst_a_String, width$1, ib); /*<>*/ if(10 === match){ - var _Y_ = /*<>*/ ignore_char(width$1, ib); + var _X_ = /*<>*/ ignore_char(width$1, ib); /*<>*/ if(counter >= 50) - return caml_trampoline_return(skip_spaces, [0, _Y_]) /*<>*/ ; + return caml_trampoline_return(skip_spaces, [0, _X_]) /*<>*/ ; var counter$0 = /*<>*/ counter + 1 | 0; - return skip_spaces(counter$0, _Y_) /*<>*/ ; + return skip_spaces(counter$0, _X_) /*<>*/ ; } /*<>*/ if(13 === match){ var width$3 = /*<>*/ ignore_char(width$1, ib); /*<>*/ if (10 === check_next_char(cst_a_String, width$3, ib)){ - var _Z_ = /*<>*/ ignore_char(width$3, ib); + var _Y_ = /*<>*/ ignore_char(width$3, ib); /*<>*/ if(counter >= 50) - return caml_trampoline_return(skip_spaces, [0, _Z_]) /*<>*/ ; + return caml_trampoline_return(skip_spaces, [0, _Y_]) /*<>*/ ; var counter$1 = /*<>*/ counter + 1 | 0; - return skip_spaces(counter$1, _Z_) /*<>*/ ; + return skip_spaces(counter$1, _Y_) /*<>*/ ; } var width$5 = /*<>*/ store_char(width$3, ib, 13); /*<>*/ width$0 = width$5; @@ -29872,21 +29833,21 @@ for(;;){ var c = /*<>*/ peek_char(ib), - _U_ = /*<>*/ 0 < i ? 1 : 0; - if(_U_){ - var _V_ = /*<>*/ 1 - ib[1]; - if(_V_) + _T_ = /*<>*/ 0 < i ? 1 : 0; + if(_T_){ + var _U_ = /*<>*/ 1 - ib[1]; + if(_U_) var - _W_ = + _V_ = /*<>*/ caml_call2 (CamlinternalFormat[1], char_set, c), - _X_ = /*<>*/ _W_ ? c !== stp ? 1 : 0 : _W_; + _W_ = /*<>*/ _V_ ? c !== stp ? 1 : 0 : _V_; else - var _X_ = /*<>*/ _V_; + var _W_ = /*<>*/ _U_; } else - var _X_ = /*<>*/ _U_; - if(! _X_) return _X_; + var _W_ = /*<>*/ _T_; + if(! _W_) return _W_; /*<>*/ store_char(Stdlib[19], ib, c); var i$0 = /*<>*/ i - 1 | 0; i = i$0; @@ -29896,8 +29857,8 @@ /*<>*/ return scan_chars(width, -1) /*<>*/ ; var c = /*<>*/ scan_indic[1]; /*<>*/ scan_chars(width, c); - var _T_ = /*<>*/ 1 - ib[1]; - if(! _T_) return _T_; + var _S_ = /*<>*/ 1 - ib[1]; + if(! _S_) return _S_; var ci = /*<>*/ peek_char(ib); /*<>*/ return c === ci ? /*<>*/ invalidate_current_char(ib) @@ -29913,7 +29874,7 @@ } var i = /*<>*/ char_count(ib); /*<>*/ return /*<>*/ bad_input - ( /*<>*/ caml_call3(Stdlib_Printf[4], _o_, i, s)) /*<>*/ ; + ( /*<>*/ caml_call3(Stdlib_Printf[4], _n_, i, s)) /*<>*/ ; } function width_of_pad_opt(pad_opt){ /*<>*/ if(! pad_opt) @@ -29923,7 +29884,7 @@ /*<>*/ } function stopper_of_formatting_lit(fmting){ /*<>*/ if(6 === fmting) - /*<>*/ return _p_; + /*<>*/ return _o_; var str = /*<>*/ caml_call1(CamlinternalFormat[17], fmting), @@ -30003,17 +29964,17 @@ var rest$13 = /*<>*/ fmt[3], fmtty = fmt[2], - _Q_ = + _P_ = /*<>*/ caml_call1 (CamlinternalFormat[21], fmtty), - _R_ = + _Q_ = /*<>*/ caml_call1 - (CamlinternalFormatBasics[2], _Q_); + (CamlinternalFormatBasics[2], _P_); /*<>*/ if(counter >= 50) return caml_trampoline_return - (take_fmtty_format_readers$0, [0, k, _R_, rest$13]) /*<>*/ ; + (take_fmtty_format_readers$0, [0, k, _Q_, rest$13]) /*<>*/ ; var counter$0 = /*<>*/ counter + 1 | 0; - return take_fmtty_format_readers$0(counter$0, k, _R_, rest$13) /*<>*/ ; + return take_fmtty_format_readers$0(counter$0, k, _Q_, rest$13) /*<>*/ ; case 15: var rest$14 = /*<>*/ fmt[1]; /*<>*/ fmt = rest$14; @@ -30027,11 +29988,11 @@ /*<>*/ fmt = rest$16; break; case 18: - var _S_ = /*<>*/ fmt[1]; - if(0 === _S_[0]){ + var _R_ = /*<>*/ fmt[1]; + if(0 === _R_[0]){ var rest$17 = fmt[2], - fmt$0 = _S_[1][1], + fmt$0 = _R_[1][1], fmt$1 = /*<>*/ caml_call2 (CamlinternalFormatBasics[3], fmt$0, rest$17); @@ -30040,7 +30001,7 @@ else{ var rest$18 = /*<>*/ fmt[2], - fmt$2 = _S_[1][1], + fmt$2 = _R_[1][1], fmt$3 = /*<>*/ caml_call2 (CamlinternalFormatBasics[3], fmt$2, rest$18); @@ -30157,11 +30118,11 @@ rest = /*<>*/ fmtty[3], ty2 = fmtty[2], ty1 = fmtty[1], - _P_ = + _O_ = /*<>*/ caml_call1(CamlinternalFormat[21], ty1), ty = /*<>*/ caml_call2 - (CamlinternalFormat[22], _P_, ty2), + (CamlinternalFormat[22], _O_, ty2), fmtty$9 = /*<>*/ caml_call2 (CamlinternalFormatBasics[1], ty, rest); @@ -30309,8 +30270,8 @@ str$0 = fmt[1]; /*<>*/ caml_call2 (Stdlib_String[30], - function(_O_){ - /*<>*/ return check_char(ib, _O_); + function(_N_){ + /*<>*/ return check_char(ib, _N_); }, str$0); /*<>*/ fmt = rest$15; @@ -30330,10 +30291,10 @@ var s = /*<>*/ token_string(ib); /*<>*/ try{ var - _E_ = + _D_ = /*<>*/ caml_call2 (CamlinternalFormat[14], s, fmtty), - fmt$2 = _E_; + fmt$2 = _D_; } catch(exn$0){ var exn = /*<>*/ caml_wrap_exception(exn$0); @@ -30360,21 +30321,21 @@ var rest$19 = /*<>*/ fmt[2], formatting_lit = fmt[1], - _K_ = + _J_ = /*<>*/ caml_call1 (CamlinternalFormat[17], formatting_lit); /*<>*/ caml_call2 (Stdlib_String[30], - function(_N_){ - /*<>*/ return check_char(ib, _N_); + function(_M_){ + /*<>*/ return check_char(ib, _M_); }, - _K_); + _J_); /*<>*/ fmt = rest$19; break; case 18: - var _L_ = /*<>*/ fmt[1]; - if(0 === _L_[0]){ - var rest$20 = fmt[2], fmt$8 = _L_[1][1]; + var _K_ = /*<>*/ fmt[1]; + if(0 === _K_[0]){ + var rest$20 = fmt[2], fmt$8 = _K_[1][1]; /*<>*/ check_char(ib, 64); /*<>*/ check_char(ib, 123); var @@ -30386,7 +30347,7 @@ else{ var rest$21 = /*<>*/ fmt[2], - fmt$10 = _L_[1][1]; + fmt$10 = _K_[1][1]; /*<>*/ check_char(ib, 64); /*<>*/ check_char(ib, 91); var @@ -30443,7 +30404,7 @@ /*<>*/ make_scanf(ib, fmt$12, readers); /*<>*/ if(! match$3) /*<>*/ throw caml_maybe_attach_backtrace - ([0, Assert_failure, _s_], 1); + ([0, Assert_failure, _r_], 1); var arg_rest = /*<>*/ match$3[2]; /*<>*/ return arg_rest; default: @@ -30502,23 +30463,23 @@ /*<>*/ caml_call2 (CamlinternalFormat[13], 0, s$0) [1], - _G_ = + _F_ = /*<>*/ caml_call1 (CamlinternalFormat[21], fmtty$0), - _H_ = + _G_ = /*<>*/ caml_call1 - (CamlinternalFormatBasics[2], _G_), + (CamlinternalFormatBasics[2], _F_), fmt$7 = /*<>*/ caml_call2 - (CamlinternalFormat[12], fmt$6, _H_), - _I_ = + (CamlinternalFormat[12], fmt$6, _G_), + _H_ = /*<>*/ caml_call1 (CamlinternalFormatBasics[2], fmtty$0), - _J_ = + _I_ = /*<>*/ caml_call2 - (CamlinternalFormat[12], fmt$5, _I_), + (CamlinternalFormat[12], fmt$5, _H_), fmt$4 = fmt$7, - fmt$3 = _J_; + fmt$3 = _I_; } catch(exn){ var exn$0 = /*<>*/ caml_wrap_exception(exn); @@ -30526,9 +30487,9 @@ throw caml_maybe_attach_backtrace(exn$0, 0); var msg$0 = exn$0[2], - _F_ = /*<>*/ bad_input(msg$0), - fmt$4 = _F_[2], - fmt$3 = _F_[1]; + _E_ = /*<>*/ bad_input(msg$0), + fmt$4 = _E_[2], + fmt$3 = _E_[1]; } /*<>*/ return [0, [0, fmt$3, s$0], @@ -30542,7 +30503,7 @@ rest$13 = /*<>*/ fmt[2], pad$8 = fmt[1], scan$8 = - /*<>*/ function(_M_, param, ib){ + /*<>*/ function(_L_, param, ib){ var c = /*<>*/ checked_peek_char(ib), m = @@ -30553,7 +30514,7 @@ ? 4 : /*<>*/ bad_input ( /*<>*/ caml_call2 - (Stdlib_Printf[4], _n_, c)); + (Stdlib_Printf[4], _m_, c)); /*<>*/ return scan_string(0, m, ib) /*<>*/ ; }; /*<>*/ return pad_prec_scanf @@ -30692,14 +30653,14 @@ /*<>*/ return pad_prec_scanf (ib, str_rest, readers, pad, 0, scan$0, token_string) /*<>*/ ; case 18: - var _D_ = /*<>*/ match[1]; - if(0 === _D_[0]){ + var _C_ = /*<>*/ match[1]; + if(0 === _C_[0]){ var rest$3 = match[2], - fmt$0 = _D_[1][1], + fmt$0 = _C_[1][1], scan$1 = /*<>*/ function(width, param, ib){ - /*<>*/ return scan_string(_q_, width, ib) /*<>*/ ; + /*<>*/ return scan_string(_p_, width, ib) /*<>*/ ; }; /*<>*/ return /*<>*/ pad_prec_scanf (ib, @@ -30713,10 +30674,10 @@ } var rest$4 = /*<>*/ match[2], - fmt$1 = _D_[1][1], + fmt$1 = _C_[1][1], scan$2 = /*<>*/ function(width, param, ib){ - /*<>*/ return scan_string(_r_, width, ib) /*<>*/ ; + /*<>*/ return scan_string(_q_, width, ib) /*<>*/ ; }; /*<>*/ return /*<>*/ pad_prec_scanf (ib, @@ -30816,12 +30777,12 @@ if(exc[1] !== Stdlib[6]) throw caml_maybe_attach_backtrace(exc, 0); var msg = exc[2], - _z_ = /*<>*/ caml_call1(Stdlib_String[25], str), - _A_ = caml_call2(Stdlib[28], _z_, cst$0), - _B_ = - /*<>*/ caml_call2(Stdlib[28], cst_in_format, _A_), - _C_ = /*<>*/ caml_call2(Stdlib[28], msg, _B_); - /*<>*/ return caml_call1(Stdlib[1], _C_) /*<>*/ ; + _y_ = /*<>*/ caml_call1(Stdlib_String[25], str), + _z_ = caml_call2(Stdlib[28], _y_, cst$0), + _A_ = + /*<>*/ caml_call2(Stdlib[28], cst_in_format, _z_), + _B_ = /*<>*/ caml_call2(Stdlib[28], msg, _A_); + /*<>*/ return caml_call1(Stdlib[1], _B_) /*<>*/ ; } /*<>*/ return caml_call2(ef, ib, exc) /*<>*/ ; } @@ -30850,7 +30811,7 @@ function kscanf_opt(ib, fmt){ /*<>*/ return kscanf_gen (ib, - function(_y_, param){ + function(_x_, param){ /*<>*/ return 0; /*<>*/ }, function(x){ @@ -30865,16 +30826,84 @@ /*<>*/ return kscanf_opt(ib, fmt) /*<>*/ ; } function ksscanf(s, ef, fmt){ - /*<>*/ return /*<>*/ kscanf - ( /*<>*/ from_string(s), ef, fmt) /*<>*/ ; + var + i = /*<>*/ [0, 0], + len = /*<>*/ caml_ml_string_length(s); + function next(param){ + /*<>*/ if(len <= i[1]) + /*<>*/ throw caml_maybe_attach_backtrace + (Stdlib[12], 1); + var c = /*<>*/ caml_string_get(s, i[1]); + /*<>*/ i[1]++; + /*<>*/ return c; + /*<>*/ } + /*<>*/ return /*<>*/ kscanf + ([0, + 0, + null_char, + 0, + 0, + 0, + 0, + next, + /*<>*/ caml_call1 + (Stdlib_Buffer[1], default_token_buffer_size), + 1], + ef, + fmt) /*<>*/ ; } function sscanf(s, fmt){ - /*<>*/ return /*<>*/ kscanf - ( /*<>*/ from_string(s), scanf_bad_input, fmt) /*<>*/ ; + var + i = /*<>*/ [0, 0], + len = /*<>*/ caml_ml_string_length(s); + function next(param){ + /*<>*/ if(len <= i[1]) + /*<>*/ throw caml_maybe_attach_backtrace + (Stdlib[12], 1); + var c = /*<>*/ caml_string_get(s, i[1]); + /*<>*/ i[1]++; + /*<>*/ return c; + /*<>*/ } + /*<>*/ return /*<>*/ kscanf + ([0, + 0, + null_char, + 0, + 0, + 0, + 0, + next, + /*<>*/ caml_call1 + (Stdlib_Buffer[1], default_token_buffer_size), + 1], + scanf_bad_input, + fmt) /*<>*/ ; } function sscanf_opt(s, fmt){ - /*<>*/ return /*<>*/ kscanf_opt - ( /*<>*/ from_string(s), fmt) /*<>*/ ; + var + i = /*<>*/ [0, 0], + len = /*<>*/ caml_ml_string_length(s); + function next(param){ + /*<>*/ if(len <= i[1]) + /*<>*/ throw caml_maybe_attach_backtrace + (Stdlib[12], 1); + var c = /*<>*/ caml_string_get(s, i[1]); + /*<>*/ i[1]++; + /*<>*/ return c; + /*<>*/ } + /*<>*/ return /*<>*/ kscanf_opt + ([0, + 0, + null_char, + 0, + 0, + 0, + 0, + next, + /*<>*/ caml_call1 + (Stdlib_Buffer[1], default_token_buffer_size), + 1], + fmt) /*<>*/ ; } function scanf(fmt){ /*<>*/ return kscanf(stdin, scanf_bad_input, fmt) /*<>*/ ; @@ -30887,10 +30916,10 @@ var str = /*<>*/ token_string(ib); /*<>*/ try{ var - _x_ = + _w_ = /*<>*/ caml_call2 (CamlinternalFormat[15], str, format), - fmt = _x_; + fmt = _w_; } catch(exn$0){ var exn = /*<>*/ caml_wrap_exception(exn$0); @@ -30902,26 +30931,49 @@ /*<>*/ return caml_call1(f, fmt) /*<>*/ ; } function sscanf_format(s, format, f){ - /*<>*/ return /*<>*/ bscanf_format - ( /*<>*/ from_string(s), format, f) /*<>*/ ; + var + i = /*<>*/ [0, 0], + len = /*<>*/ caml_ml_string_length(s); + function next(param){ + /*<>*/ if(len <= i[1]) + /*<>*/ throw caml_maybe_attach_backtrace + (Stdlib[12], 1); + var c = /*<>*/ caml_string_get(s, i[1]); + /*<>*/ i[1]++; + /*<>*/ return c; + /*<>*/ } + /*<>*/ return /*<>*/ bscanf_format + ([0, + 0, + null_char, + 0, + 0, + 0, + 0, + next, + /*<>*/ caml_call1 + (Stdlib_Buffer[1], default_token_buffer_size), + 1], + format, + f) /*<>*/ ; } function format_from_string(s, fmt){ var - _v_ = /*<>*/ caml_call1(Stdlib_String[25], s), - _w_ = caml_call2(Stdlib[28], _v_, cst$1); + _u_ = /*<>*/ caml_call1(Stdlib_String[25], s), + _v_ = caml_call2(Stdlib[28], _u_, cst$1); /*<>*/ return /*<>*/ sscanf_format - ( /*<>*/ caml_call2(Stdlib[28], cst$2, _w_), + ( /*<>*/ caml_call2(Stdlib[28], cst$2, _v_), fmt, function(x){ /*<>*/ return x; /*<>*/ }) /*<>*/ ; } function unescaped(s){ - var _u_ = /*<>*/ caml_call2(Stdlib[28], s, cst$3); + var _t_ = /*<>*/ caml_call2(Stdlib[28], s, cst$3); /*<>*/ return /*<>*/ caml_call1 (sscanf - ( /*<>*/ caml_call2(Stdlib[28], cst$4, _u_), - _t_), + ( /*<>*/ caml_call2(Stdlib[28], cst$4, _t_), + _s_), function(x){ /*<>*/ return x; /*<>*/ }) /*<>*/ ; @@ -31693,6 +31745,205 @@ = 0; /*<>*/ return n$0; /*<>*/ } + function method_impl(table, i, arr){ + function next(param){ + /*<>*/ i[1]++; + var _m_ = /*<>*/ i[1]; + /*<>*/ return caml_check_bound(arr, _m_) + [1 + _m_] /*<>*/ ; + } + var clo = /*<>*/ next(0); + /*<>*/ if(typeof clo === "number") + switch(clo){ + case 0: + var x = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return x; /*<>*/ } /*<>*/ ; + case 1: + var n = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return obj[1 + n]; /*<>*/ } /*<>*/ ; + case 2: + var + e = /*<>*/ next(0), + n$0 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return obj[1 + e][1 + n$0]; /*<>*/ } /*<>*/ ; + case 3: + var n$1 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call1 + (obj[1][1 + n$1], obj) /*<>*/ ;} /*<>*/ ; + case 4: + var n$2 = /*<>*/ next(0); + /*<>*/ return function(obj, x){ + /*<>*/ obj[1 + n$2] = x; + return 0; /*<>*/ } /*<>*/ ; + case 5: + var + f = /*<>*/ next(0), + x$0 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call1(f, x$0) /*<>*/ ;} /*<>*/ ; + case 6: + var + f$0 = /*<>*/ next(0), + n$3 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call1 + (f$0, obj[1 + n$3]) /*<>*/ ;} /*<>*/ ; + case 7: + var + f$1 = /*<>*/ next(0), + e$0 = /*<>*/ next(0), + n$4 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call1 + (f$1, obj[1 + e$0][1 + n$4]) /*<>*/ ;} /*<>*/ ; + case 8: + var + f$2 = /*<>*/ next(0), + n$5 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return /*<>*/ caml_call1 + (f$2, + /*<>*/ caml_call1 + (obj[1][1 + n$5], obj)) /*<>*/ ;} /*<>*/ ; + case 9: + var + f$3 = /*<>*/ next(0), + x$1 = /*<>*/ next(0), + y = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call2(f$3, x$1, y) /*<>*/ ;} /*<>*/ ; + case 10: + var + f$4 = /*<>*/ next(0), + x$2 = /*<>*/ next(0), + n$6 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call2 + (f$4, x$2, obj[1 + n$6]) /*<>*/ ;} /*<>*/ ; + case 11: + var + f$5 = /*<>*/ next(0), + x$3 = /*<>*/ next(0), + e$1 = /*<>*/ next(0), + n$7 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call2 + (f$5, x$3, obj[1 + e$1][1 + n$7]) /*<>*/ ;} /*<>*/ ; + case 12: + var + f$6 = /*<>*/ next(0), + x$4 = /*<>*/ next(0), + n$8 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return /*<>*/ caml_call2 + (f$6, + x$4, + /*<>*/ caml_call1 + (obj[1][1 + n$8], obj)) /*<>*/ ;} /*<>*/ ; + case 13: + var + f$7 = /*<>*/ next(0), + n$9 = /*<>*/ next(0), + x$5 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call2 + (f$7, obj[1 + n$9], x$5) /*<>*/ ;} /*<>*/ ; + case 14: + var + f$8 = /*<>*/ next(0), + e$2 = /*<>*/ next(0), + n$10 = /*<>*/ next(0), + x$6 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call2 + (f$8, obj[1 + e$2][1 + n$10], x$6) /*<>*/ ;} /*<>*/ ; + case 15: + var + f$9 = /*<>*/ next(0), + n$11 = /*<>*/ next(0), + x$7 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return /*<>*/ caml_call2 + (f$9, + /*<>*/ caml_call1 + (obj[1][1 + n$11], obj), + x$7) /*<>*/ ;} /*<>*/ ; + case 16: + var + n$12 = /*<>*/ next(0), + x$8 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call2 + (obj[1][1 + n$12], obj, x$8) /*<>*/ ;} /*<>*/ ; + case 17: + var + n$13 = /*<>*/ next(0), + m = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call2 + (obj[1][1 + n$13], obj, obj[1 + m]) /*<>*/ ;} /*<>*/ ; + case 18: + var + n$14 = /*<>*/ next(0), + e$3 = /*<>*/ next(0), + m$0 = /*<>*/ next(0); + /*<>*/ return function(obj){ + /*<>*/ return caml_call2 + (obj[1][1 + n$14], obj, obj[1 + e$3][1 + m$0]) /*<>*/ ;} /*<>*/ ; + case 19: + var + n$15 = /*<>*/ next(0), + m$1 = /*<>*/ next(0); + /*<>*/ return function(obj){ + var + _l_ = + /*<>*/ caml_call1(obj[1][1 + m$1], obj); + /*<>*/ return caml_call2 + (obj[1][1 + n$15], obj, _l_);} /*<>*/ ; + case 20: + var + m$2 = /*<>*/ next(0), + x$9 = /*<>*/ next(0); + /*<>*/ new_cache(table); + /*<>*/ return function(obj){ + /*<>*/ return caml_call1 + (caml_get_public_method(x$9, m$2, 0), x$9) /*<>*/ ;} /*<>*/ ; + case 21: + var + m$3 = /*<>*/ next(0), + n$16 = /*<>*/ next(0); + /*<>*/ new_cache(table); + /*<>*/ return function(obj){ + var _k_ = /*<>*/ obj[1 + n$16]; + return caml_call1(caml_get_public_method(_k_, m$3, 0), _k_) /*<>*/ ;} /*<>*/ ; + case 22: + var + m$4 = /*<>*/ next(0), + e$4 = /*<>*/ next(0), + n$17 = /*<>*/ next(0); + /*<>*/ new_cache(table); + /*<>*/ return function(obj){ + var _j_ = /*<>*/ obj[1 + e$4][1 + n$17]; + return caml_call1(caml_get_public_method(_j_, m$4, 0), _j_) /*<>*/ ;} /*<>*/ ; + default: + var + m$5 = /*<>*/ next(0), + n$18 = /*<>*/ next(0); + /*<>*/ new_cache(table); + /*<>*/ return function(obj){ + var + _i_ = + /*<>*/ caml_call1 + (obj[1][1 + n$18], obj); + /*<>*/ return caml_call1 + (caml_get_public_method(_i_, m$5, 0), _i_) /*<>*/ ;} /*<>*/ ; + } + /*<>*/ return clo; + /*<>*/ } function set_methods(table, methods){ var len = /*<>*/ methods.length - 1, @@ -31704,361 +31955,8 @@ label = /*<>*/ caml_check_bound(methods, _h_) [1 + _h_], - next = - /*<>*/ function(param){ - /*<>*/ i[1]++; - var _m_ = /*<>*/ i[1]; - /*<>*/ return caml_check_bound - (methods, _m_) - [1 + _m_] /*<>*/ ; - }, - clo = /*<>*/ next(0); - /*<>*/ if(typeof clo === "number") - switch(clo){ - case 0: - var x = /*<>*/ next(0); - let x$20 = /*<>*/ x; - var - clo$0 = - function(obj){ - /*<>*/ return x$20; - /*<>*/ }; - break; - case 1: - var n = /*<>*/ next(0); - let n$38 = /*<>*/ n; - var - clo$0 = - function(obj){ - /*<>*/ return obj[1 + n$38]; - /*<>*/ }; - break; - case 2: - var - e = /*<>*/ next(0), - n$0 = /*<>*/ next(0); - let e$10 = /*<>*/ e, n$37 = n$0; - var - clo$0 = - function(obj){ - /*<>*/ return obj[1 + e$10][1 + n$37]; - /*<>*/ }; - break; - case 3: - var n$1 = /*<>*/ next(0); - let n$36 = /*<>*/ n$1; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call1 - (obj[1][1 + n$36], obj) /*<>*/ ; - }; - break; - case 4: - var n$2 = /*<>*/ next(0); - let n$35 = /*<>*/ n$2; - var - clo$0 = - function(obj, x){ - /*<>*/ obj[1 + n$35] = x; - return 0; - /*<>*/ }; - break; - case 5: - var - f = /*<>*/ next(0), - x$0 = /*<>*/ next(0); - let f$20 = /*<>*/ f, x$19 = x$0; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call1(f$20, x$19) /*<>*/ ; - }; - break; - case 6: - var - f$0 = /*<>*/ next(0), - n$3 = /*<>*/ next(0); - let f$19 = /*<>*/ f$0, n$34 = n$3; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call1 - (f$19, obj[1 + n$34]) /*<>*/ ; - }; - break; - case 7: - var - f$1 = /*<>*/ next(0), - e$0 = /*<>*/ next(0), - n$4 = /*<>*/ next(0); - let - f$18 = /*<>*/ f$1, - e$9 = e$0, - n$33 = n$4; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call1 - (f$18, obj[1 + e$9][1 + n$33]) /*<>*/ ; - }; - break; - case 8: - var - f$2 = /*<>*/ next(0), - n$5 = /*<>*/ next(0); - let f$17 = /*<>*/ f$2, n$32 = n$5; - var - clo$0 = - function(obj){ - /*<>*/ return /*<>*/ caml_call1 - (f$17, - /*<>*/ caml_call1 - (obj[1][1 + n$32], obj)) /*<>*/ ; - }; - break; - case 9: - var - f$3 = /*<>*/ next(0), - x$1 = /*<>*/ next(0), - y = /*<>*/ next(0); - let - f$16 = /*<>*/ f$3, - x$18 = x$1, - y$0 = y; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call2 - (f$16, x$18, y$0) /*<>*/ ; - }; - break; - case 10: - var - f$4 = /*<>*/ next(0), - x$2 = /*<>*/ next(0), - n$6 = /*<>*/ next(0); - let - f$15 = /*<>*/ f$4, - x$17 = x$2, - n$31 = n$6; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call2 - (f$15, x$17, obj[1 + n$31]) /*<>*/ ; - }; - break; - case 11: - var - f$5 = /*<>*/ next(0), - x$3 = /*<>*/ next(0), - e$1 = /*<>*/ next(0), - n$7 = /*<>*/ next(0); - let - f$14 = /*<>*/ f$5, - x$16 = x$3, - e$8 = e$1, - n$30 = n$7; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call2 - (f$14, x$16, obj[1 + e$8][1 + n$30]) /*<>*/ ; - }; - break; - case 12: - var - f$6 = /*<>*/ next(0), - x$4 = /*<>*/ next(0), - n$8 = /*<>*/ next(0); - let - f$13 = /*<>*/ f$6, - x$15 = x$4, - n$29 = n$8; - var - clo$0 = - function(obj){ - /*<>*/ return /*<>*/ caml_call2 - (f$13, - x$15, - /*<>*/ caml_call1 - (obj[1][1 + n$29], obj)) /*<>*/ ; - }; - break; - case 13: - var - f$7 = /*<>*/ next(0), - n$9 = /*<>*/ next(0), - x$5 = /*<>*/ next(0); - let - f$12 = /*<>*/ f$7, - n$28 = n$9, - x$14 = x$5; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call2 - (f$12, obj[1 + n$28], x$14) /*<>*/ ; - }; - break; - case 14: - var - f$8 = /*<>*/ next(0), - e$2 = /*<>*/ next(0), - n$10 = /*<>*/ next(0), - x$6 = /*<>*/ next(0); - let - f$11 = /*<>*/ f$8, - e$7 = e$2, - n$27 = n$10, - x$13 = x$6; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call2 - (f$11, obj[1 + e$7][1 + n$27], x$13) /*<>*/ ; - }; - break; - case 15: - var - f$9 = /*<>*/ next(0), - n$11 = /*<>*/ next(0), - x$7 = /*<>*/ next(0); - let - f$10 = /*<>*/ f$9, - n$26 = n$11, - x$12 = x$7; - var - clo$0 = - function(obj){ - /*<>*/ return /*<>*/ caml_call2 - (f$10, - /*<>*/ caml_call1 - (obj[1][1 + n$26], obj), - x$12) /*<>*/ ; - }; - break; - case 16: - var - n$12 = /*<>*/ next(0), - x$8 = /*<>*/ next(0); - let n$25 = /*<>*/ n$12, x$11 = x$8; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call2 - (obj[1][1 + n$25], obj, x$11) /*<>*/ ; - }; - break; - case 17: - var - n$13 = /*<>*/ next(0), - m = /*<>*/ next(0); - let n$24 = /*<>*/ n$13, m$12 = m; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call2 - (obj[1][1 + n$24], obj, obj[1 + m$12]) /*<>*/ ; - }; - break; - case 18: - var - n$14 = /*<>*/ next(0), - e$3 = /*<>*/ next(0), - m$0 = /*<>*/ next(0); - let - n$23 = /*<>*/ n$14, - e$6 = e$3, - m$11 = m$0; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call2 - (obj[1][1 + n$23], obj, obj[1 + e$6][1 + m$11]) /*<>*/ ; - }; - break; - case 19: - var - n$15 = /*<>*/ next(0), - m$1 = /*<>*/ next(0); - let n$22 = /*<>*/ n$15, m$10 = m$1; - var - clo$0 = - function(obj){ - var - _l_ = - /*<>*/ caml_call1 - (obj[1][1 + m$10], obj); - /*<>*/ return caml_call2 - (obj[1][1 + n$22], obj, _l_); - }; - break; - case 20: - var - m$2 = /*<>*/ next(0), - x$9 = /*<>*/ next(0); - /*<>*/ new_cache(table); - let m$9 = /*<>*/ m$2, x$10 = x$9; - var - clo$0 = - function(obj){ - /*<>*/ return caml_call1 - (caml_get_public_method(x$10, m$9, 0), x$10) /*<>*/ ; - }; - break; - case 21: - var - m$3 = /*<>*/ next(0), - n$16 = /*<>*/ next(0); - /*<>*/ new_cache(table); - let m$8 = /*<>*/ m$3, n$21 = n$16; - var - clo$0 = - function(obj){ - var _k_ = /*<>*/ obj[1 + n$21]; - return caml_call1(caml_get_public_method(_k_, m$8, 0), _k_) /*<>*/ ; - }; - break; - case 22: - var - m$4 = /*<>*/ next(0), - e$4 = /*<>*/ next(0), - n$17 = /*<>*/ next(0); - /*<>*/ new_cache(table); - let - m$7 = /*<>*/ m$4, - e$5 = e$4, - n$20 = n$17; - var - clo$0 = - function(obj){ - var - _j_ = /*<>*/ obj[1 + e$5][1 + n$20]; - return caml_call1(caml_get_public_method(_j_, m$7, 0), _j_) /*<>*/ ; - }; - break; - default: - var - m$5 = /*<>*/ next(0), - n$18 = /*<>*/ next(0); - /*<>*/ new_cache(table); - let m$6 = /*<>*/ m$5, n$19 = n$18; - var - clo$0 = - function(obj){ - var - _i_ = - /*<>*/ caml_call1 - (obj[1][1 + n$19], obj); - /*<>*/ return caml_call1 - (caml_get_public_method(_i_, m$6, 0), _i_) /*<>*/ ; - }; - } - else - var clo$0 = /*<>*/ clo; - /*<>*/ set_method(table, label, clo$0); + clo = /*<>*/ method_impl(table, i, methods); + /*<>*/ set_method(table, label, clo); /*<>*/ i[1]++; } /*<>*/ } @@ -33207,7 +33105,7 @@ } /*<>*/ } function filter(f, a){ - var b = /*<>*/ create(0); + var b = /*<>*/ [0, 0, [0], dummy]; /*<>*/ iter (cst_filter, function(x){ @@ -33220,7 +33118,7 @@ /*<>*/ return b; /*<>*/ } function filter_map(f, a){ - var b = /*<>*/ create(0); + var b = /*<>*/ [0, 0, [0], dummy]; /*<>*/ iter (cst_filter_map, function(x){ @@ -33486,7 +33384,7 @@ /*<>*/ return l[1]; /*<>*/ } function of_seq(seq){ - var init = /*<>*/ create(0); + var init = /*<>*/ [0, 0, [0], dummy]; /*<>*/ append_seq(init, seq); /*<>*/ return init; /*<>*/ } @@ -35974,9 +35872,11 @@ _b_] /*<>*/ ; /*<>*/ } function pow(x, y){ - /*<>*/ return /*<>*/ exp - ( /*<>*/ mul - (y, /*<>*/ log(x))) /*<>*/ ; + var y$0 = /*<>*/ log(x); + /*<>*/ return exp + ([254, + y[1] * y$0[1] - y[2] * y$0[2], + y[1] * y$0[2] + y[2] * y$0[1]]); } var Stdlib_Complex = From f76ab7499010b2930384597f80f3e5b38c5aee17 Mon Sep 17 00:00:00 2001 From: Hugo Heuzard Date: Fri, 25 Apr 2025 10:58:14 +0200 Subject: [PATCH 6/7] fixup! Update tests --- compiler/tests-compiler/direct_calls.ml | 193 +++++++++++++++--- .../double-translation/direct_calls.ml | 184 +++++++++++++---- compiler/tests-compiler/gh1320.ml | 30 ++- compiler/tests-compiler/global_deadcode.ml | 23 +-- 4 files changed, 326 insertions(+), 104 deletions(-) diff --git a/compiler/tests-compiler/direct_calls.ml b/compiler/tests-compiler/direct_calls.ml index ac298fbb52..1466e6ddaf 100644 --- a/compiler/tests-compiler/direct_calls.ml +++ b/compiler/tests-compiler/direct_calls.ml @@ -22,21 +22,31 @@ let%expect_test "direct calls without --effects=cps" = let code = compile_and_parse {| + let l = ref [] + (* Arity of the argument of a function / direct call *) let test1 () = - let f g x = try g x with e -> raise e in + let f g x = + l := (fun () -> ()) :: !l; (* pervent inlining *) + try g x with e -> raise e in ignore (f (fun x -> x + 1) 7); ignore (f (fun x -> x *. 2.) 4.) (* Arity of the argument of a function / CPS call *) let test2 () = - let f g x = try g x with e -> raise e in + let f g x = + l := (fun () -> ()) :: !l; (* pervent inlining *) + try g x with e -> raise e in ignore (f (fun x -> x + 1) 7); ignore (f (fun x -> x ^ "a") "a") (* Arity of functions in a functor / direct call *) let test3 x = - let module F(_ : sig end) = struct let f x = x + 1 end in + let module F(_ : sig end) = struct + let r = ref 0 + let () = for _ = 0 to 2 do incr r done (* pervent inlining *) + let f x = x + 1 + end in let module M1 = F (struct end) in let module M2 = F (struct end) in (M1.f 1, M2.f 2) @@ -44,7 +54,11 @@ let%expect_test "direct calls without --effects=cps" = (* Arity of functions in a functor / CPS call *) let test4 x = let module F(_ : sig end) = - struct let f x = Printf.printf "%d" x end in + struct + let r = ref 0 + let () = for _ = 0 to 2 do incr r done (* pervent inlining *) + let f x = Printf.printf "%d" x + end in let module M1 = F (struct end) in let module M2 = F (struct end) in M1.f 1; M2.f 2 @@ -56,45 +70,99 @@ let%expect_test "direct calls without --effects=cps" = print_fun_decl code (Some "test4"); [%expect {| - function test1(param){return 0;} + function test1(param){ + function f(g, x){ + l[1] = [0, function(param){return 0;}, l[1]]; + try{caml_call1(g, x); return;} + catch(e$0){ + var e = caml_wrap_exception(e$0); + throw caml_maybe_attach_backtrace(e, 0); + } + } + f(function(x){return x + 1 | 0;}, 7); + f(function(x){return x * 2.;}, 4.); + return 0; + } //end function test2(param){ - try{caml_call2(Stdlib[28], x, cst_a);} - catch(e$0){ - var e = caml_wrap_exception(e$0); - throw caml_maybe_attach_backtrace(e, 0); + function f(g, x){ + l[1] = [0, function(param){return 0;}, l[1]]; + try{caml_call1(g, x); return;} + catch(e$0){ + var e = caml_wrap_exception(e$0); + throw caml_maybe_attach_backtrace(e, 0); + } } + f(function(x){return x + 1 | 0;}, 7); + f(function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, cst_a); return 0; } //end - function test3(x){return [0, 2, 3];} + function test3(x){ + function F(symbol){ + var r = [0, 0], for$0 = 0; + for(;;){ + r[1]++; + var _d_ = for$0 + 1 | 0; + if(2 === for$0) break; + for$0 = _d_; + } + function f(x){return x + 1 | 0;} + return [0, , f]; + } + var M1 = F([0]), M2 = F([0]), _c_ = M2[2].call(null, 2); + return [0, M1[2].call(null, 1), _c_]; + } //end function test4(x){ - caml_call2(Stdlib_Printf[2], _a_, 1); - return caml_call2(Stdlib_Printf[2], _a_, 2); + function F(symbol){ + var r = [0, 0], for$0 = 0; + for(;;){ + r[1]++; + var _b_ = for$0 + 1 | 0; + if(2 === for$0) break; + for$0 = _b_; + } + function f(x){return caml_call2(Stdlib_Printf[2], _a_, x);} + return [0, , f]; + } + var M1 = F([0]), M2 = F([0]); + M1[2].call(null, 1); + return M2[2].call(null, 2); } - //end |}] + //end + |}] let%expect_test "direct calls with --effects=cps" = let code = compile_and_parse ~effects:`Cps {| + let l = ref [] + (* Arity of the argument of a function / direct call *) let test1 () = - let f g x = try g x with e -> raise e in + let f g x = + l := (fun () -> ()) :: !l; (* pervent inlining *) + try g x with e -> raise e in ignore (f (fun x -> x + 1) 7); ignore (f (fun x -> x *. 2.) 4.) (* Arity of the argument of a function / CPS call *) let test2 () = - let f g x = try g x with e -> raise e in + let f g x = + l := (fun () -> ()) :: !l; (* pervent inlining *) + try g x with e -> raise e in ignore (f (fun x -> x + 1) 7); ignore (f (fun x -> x ^ "a") "a") (* Arity of functions in a functor / direct call *) let test3 x = - let module F(_ : sig end) = struct let f x = x + 1 end in + let module F(_ : sig end) = struct + let r = ref 0 + let () = for _ = 0 to 2 do incr r done (* pervent inlining *) + let f x = x + 1 + end in let module M1 = F (struct end) in let module M2 = F (struct end) in (M1.f 1, M2.f 2) @@ -102,7 +170,11 @@ let%expect_test "direct calls with --effects=cps" = (* Arity of functions in a functor / CPS call *) let test4 x = let module F(_ : sig end) = - struct let f x = Printf.printf "%d" x end in + struct + let r = ref 0 + let () = for _ = 0 to 2 do incr r done (* pervent inlining *) + let f x = Printf.printf "%d" x + end in let module M1 = F (struct end) in let module M2 = F (struct end) in M1.f 1; M2.f 2 @@ -114,30 +186,83 @@ let%expect_test "direct calls with --effects=cps" = print_fun_decl code (Some "test4"); [%expect {| - function test1(param, cont){return cont(0);} + function test1(param, cont){ + function f(g, x){ + l[1] = [0, function(param, cont){return cont(0);}, l[1]]; + try{g(); return;} + catch(e$0){ + var e = caml_wrap_exception(e$0); + throw caml_maybe_attach_backtrace(e, 0); + } + } + f(function(x){}); + f(function(x){}); + return cont(0); + } //end function test2(param, cont){ - runtime.caml_push_trap - (function(e){ - var raise = caml_pop_trap(), e$0 = caml_maybe_attach_backtrace(e, 0); - return raise(e$0); - }); - return caml_trampoline_cps_call3 - (Stdlib[28], - x, - cst_a, - function(_g_){caml_pop_trap(); return cont(0);}); + function f(g, x, cont){ + l[1] = [0, function(param, cont){return cont(0);}, l[1]]; + runtime.caml_push_trap + (function(e){ + var raise = caml_pop_trap(), e$0 = caml_maybe_attach_backtrace(e, 0); + return raise(e$0); + }); + return caml_exact_trampoline_cps_call + (g, x, function(_x_){caml_pop_trap(); return cont();}); + } + return caml_exact_trampoline_cps_call$0 + (f, + function(x, cont){return cont();}, + 7, + function(_v_){ + return caml_exact_trampoline_cps_call$0 + (f, + function(x, cont){ + return caml_trampoline_cps_call3 + (Stdlib[28], x, cst_a$0, cont); + }, + cst_a, + function(_w_){return cont(0);}); + }); } //end - function test3(x, cont){return cont([0, 2, 3]);} + function test3(x, cont){ + function F(symbol){ + var r = [0, 0], for$0 = 0; + for(;;){ + r[1]++; + var _u_ = for$0 + 1 | 0; + if(2 === for$0) break; + for$0 = _u_; + } + function f(x){return x + 1 | 0;} + return [0, , f]; + } + var M1 = F(), M2 = F(), _t_ = M2[2].call(null, 2); + return cont([0, M1[2].call(null, 1), _t_]); + } //end function test4(x, cont){ - return caml_trampoline_cps_call3 - (Stdlib_Printf[2], - _e_, + function F(symbol){ + var r = [0, 0], for$0 = 0; + for(;;){ + r[1]++; + var _s_ = for$0 + 1 | 0; + if(2 === for$0) break; + for$0 = _s_; + } + function f(x, cont){ + return caml_trampoline_cps_call3(Stdlib_Printf[2], _q_, x, cont); + } + return [0, , f]; + } + var M1 = F(), M2 = F(); + return caml_exact_trampoline_cps_call + (M1[2], 1, - function(_f_){ - return caml_trampoline_cps_call3(Stdlib_Printf[2], _e_, 2, cont); + function(_r_){ + return caml_exact_trampoline_cps_call(M2[2], 2, cont); }); } //end diff --git a/compiler/tests-compiler/double-translation/direct_calls.ml b/compiler/tests-compiler/double-translation/direct_calls.ml index 857ec50cc0..d854a3cbf0 100644 --- a/compiler/tests-compiler/double-translation/direct_calls.ml +++ b/compiler/tests-compiler/double-translation/direct_calls.ml @@ -23,21 +23,31 @@ let%expect_test "direct calls with --effects=double-translation" = compile_and_parse ~effects:`Double_translation {| + let l = ref [] + (* Arity of the argument of a function / direct call *) let test1 () = - let f g x = try g x with e -> raise e in + let f g x = + l := (fun () -> ()) :: !l; (* pervent inlining *) + try g x with e -> raise e in ignore (f (fun x -> x + 1) 7); ignore (f (fun x -> x *. 2.) 4.) (* Arity of the argument of a function / CPS call *) let test2 () = - let f g x = try g x with e -> raise e in + let f g x = + l := (fun () -> ()) :: !l; (* pervent inlining *) + try g x with e -> raise e in ignore (f (fun x -> x + 1) 7); ignore (f (fun x -> x ^ "a") "a") (* Arity of functions in a functor / direct call *) let test3 x = - let module F(_ : sig end) = struct let f x = x + 1 end in + let module F(_ : sig end) = struct + let r = ref 0 + let () = for _ = 0 to 2 do incr r done (* pervent inlining *) + let f x = x + 1 + end in let module M1 = F (struct end) in let module M2 = F (struct end) in (M1.f 1, M2.f 2) @@ -45,7 +55,11 @@ let%expect_test "direct calls with --effects=double-translation" = (* Arity of functions in a functor / CPS call *) let test4 x = let module F(_ : sig end) = - struct let f x = Printf.printf "%d" x end in + struct + let r = ref 0 + let () = for _ = 0 to 2 do incr r done (* pervent inlining *) + let f x = Printf.printf "%d" x + end in let module M1 = F (struct end) in let module M2 = F (struct end) in M1.f 1; M2.f 2 @@ -53,6 +67,7 @@ let%expect_test "direct calls with --effects=double-translation" = (* Result of double-translating two mutually recursive functions *) let test5 () = let g x = + l := (fun () -> ()) :: !l; (* pervent inlining *) let rec f y = if y = 0 then 1 else x + h (y - 1) and h z = if z = 0 then 1 else x + f (z - 1) in @@ -121,50 +136,135 @@ let%expect_test "direct calls with --effects=double-translation" = : runtime.caml_call_gen(f, [a0, a1])) : runtime.caml_trampoline_return(f, [a0, a1, a2], 0); } + function caml_exact_trampoline_cps_call$0(f, a0, a1, a2){ + return runtime.caml_stack_check_depth() + ? f.cps ? f.cps.call(null, a0, a1, a2) : a2(f(a0, a1)) + : runtime.caml_trampoline_return(f, [a0, a1, a2], 0); + } var + dummy = 0, global_data = runtime.caml_get_global_data(), - _k_ = [0, [4, 0, 0, 0, 0], caml_string_of_jsbytes("%d")], + _E_ = [0, [4, 0, 0, 0, 0], caml_string_of_jsbytes("%d")], + cst_a$0 = caml_string_of_jsbytes("a"), cst_a = caml_string_of_jsbytes("a"), - x = caml_string_of_jsbytes("a"), Stdlib = global_data.Stdlib, - Stdlib_Printf = global_data.Stdlib__Printf; - function test1(param){return 0;} - function test2$0(param){ - try{caml_call2(Stdlib[28], x, cst_a);} - catch(e$0){ - var e = caml_wrap_exception(e$0); - throw caml_maybe_attach_backtrace(e, 0); + Stdlib_Printf = global_data.Stdlib__Printf, + l = [0, 0]; + function test1(param){ + function f(g, x){ + l[1] = [0, function(param){return 0;}, l[1]]; + try{caml_call1(g, dummy); return;} + catch(e$0){ + var e = caml_wrap_exception(e$0); + throw caml_maybe_attach_backtrace(e, 0); + } } + f(function(x){}); + f(function(x){}); + return 0; + } + function _g_(){return function(param){return 0;};} + function f$0(){ + function f$0(g, x){ + var _V_ = l[1]; + l[1] = [0, _g_(), _V_]; + try{caml_call1(g, x); return;} + catch(e$0){ + var e = caml_wrap_exception(e$0); + throw caml_maybe_attach_backtrace(e, 0); + } + } + function f$1(g, x, cont){ + var _T_ = l[1]; + l[1] = [0, _g_(), _T_]; + runtime.caml_push_trap + (function(e$0){ + var raise = caml_pop_trap(), e = caml_maybe_attach_backtrace(e$0, 0); + return raise(e); + }); + return caml_exact_trampoline_cps_call + (g, x, function(_U_){caml_pop_trap(); return cont();}); + } + var f = caml_cps_closure(f$0, f$1); + return f; + } + function _k_(){return function(x){};} + function _m_(){ + return caml_cps_closure + (function(x){return caml_call2(Stdlib[28], x, cst_a$0);}, + function(x, cont){ + return caml_trampoline_cps_call3(Stdlib[28], x, cst_a$0, cont); + }); + } + function test2$0(param){ + var f = f$0(); + f(_k_(), 7); + f(_m_(), cst_a); return 0; } function test2$1(param, cont){ - runtime.caml_push_trap - (function(e$0){ - var raise = caml_pop_trap(), e = caml_maybe_attach_backtrace(e$0, 0); - return raise(e); - }); - return caml_trampoline_cps_call3 - (Stdlib[28], - x, - cst_a, - function(_s_){caml_pop_trap(); return cont(0);}); + var f = f$0(); + return caml_exact_trampoline_cps_call$0 + (f, + _k_(), + 7, + function(_R_){ + return caml_exact_trampoline_cps_call$0 + (f, _m_(), cst_a, function(_S_){return cont(0);}); + }); } var test2 = caml_cps_closure(test2$0, test2$1); - function test3(x){return [0, 2, 3];} + function test3(x){ + function F(symbol){ + var r = [0, 0], for$0 = 0; + for(;;){ + r[1]++; + var _Q_ = for$0 + 1 | 0; + if(2 === for$0) break; + for$0 = _Q_; + } + function f(x){return x + 1 | 0;} + return [0, , f]; + } + var M1 = F(), M2 = F(), _P_ = caml_call1(M2[2], 2); + return [0, caml_call1(M1[2], 1), _P_]; + } + function f(){ + function f$0(x){return caml_call2(Stdlib_Printf[2], _E_, x);} + function f$1(x, cont){ + return caml_trampoline_cps_call3(Stdlib_Printf[2], _E_, x, cont); + } + var f = caml_cps_closure(f$0, f$1); + return f; + } + function F(){ + function F(symbol){ + var r = [0, 0], for$0 = 0; + for(;;){ + r[1]++; + var _O_ = for$0 + 1 | 0; + if(2 === for$0){var f$0 = f(); return [0, , f$0];} + for$0 = _O_; + } + } + return F; + } function test4$0(x){ - caml_call2(Stdlib_Printf[2], _k_, 1); - return caml_call2(Stdlib_Printf[2], _k_, 2); + var F$0 = F(), M1 = F$0(), M2 = F$0(); + caml_call1(M1[2], 1); + return caml_call1(M2[2], 2); } function test4$1(x, cont){ - return caml_trampoline_cps_call3 - (Stdlib_Printf[2], - _k_, + var F$0 = F(), M1 = F$0(), M2 = F$0(); + return caml_exact_trampoline_cps_call + (M1[2], 1, - function(_r_){ - return caml_trampoline_cps_call3(Stdlib_Printf[2], _k_, 2, cont); + function(_N_){ + return caml_exact_trampoline_cps_call(M2[2], 2, cont); }); } var test4 = caml_cps_closure(test4$0, test4$1); + function _x_(){return function(param){return 0;};} function recfuncs(x){ function f(y){return 0 === y ? 1 : x + h(y - 1 | 0) | 0;} function h(z){return 0 === z ? 1 : x + f(z - 1 | 0) | 0;} @@ -173,22 +273,26 @@ let%expect_test "direct calls with --effects=double-translation" = } function g(){ function g$0(x){ + var _K_ = l[1]; + l[1] = [0, _x_(), _K_]; var tuple = recfuncs(x), f = tuple[2], h = tuple[1], - _p_ = h(100), - _q_ = f(12) + _p_ | 0; - return caml_call1(Stdlib[44], _q_); + _L_ = h(100), + _M_ = f(12) + _L_ | 0; + return caml_call1(Stdlib[44], _M_); } function g$1(x, cont){ + var _H_ = l[1]; + l[1] = [0, _x_(), _H_]; var tuple = recfuncs(x), f = tuple[2], h = tuple[1], - _n_ = h(100), - _o_ = f(12) + _n_ | 0; - return caml_trampoline_cps_call2(Stdlib[44], _o_, cont); + _I_ = h(100), + _J_ = f(12) + _I_ | 0; + return caml_trampoline_cps_call2(Stdlib[44], _J_, cont); } var g = caml_cps_closure(g$0, g$1); return g; @@ -199,14 +303,14 @@ let%expect_test "direct calls with --effects=double-translation" = return caml_exact_trampoline_cps_call (g$0, 42, - function(_l_){ + function(_F_){ return caml_exact_trampoline_cps_call - (g$0, - 5, function(_m_){return cont(0);}); + (g$0, - 5, function(_G_){return cont(0);}); }); } var test5 = caml_cps_closure(test5$0, test5$1), - Test = [0, test1, test2, test3, test4, test5]; + Test = [0, l, test1, test2, test3, test4, test5]; runtime.caml_register_global(7, Test, "Test"); return; } diff --git a/compiler/tests-compiler/gh1320.ml b/compiler/tests-compiler/gh1320.ml index 53f63e0954..3b86d7944f 100644 --- a/compiler/tests-compiler/gh1320.ml +++ b/compiler/tests-compiler/gh1320.ml @@ -22,7 +22,8 @@ let%expect_test _ = let prog = {| -let app f x = try f x with e -> raise e +exception I of int +let app f x = try f x with e -> raise (I (f x)) let myfun () = for i = 1 to 4 do @@ -48,23 +49,18 @@ let () = myfun () for(;;){ let i$0 = i; var - g = + f = function(x){ - try{ - var _d_ = 0 === x ? 1 : runtime.caml_mul(i$0, app(g$0, x - 1 | 0)); - return _d_; - } - catch(e$0){ - var e = caml_wrap_exception(e$0); - throw caml_maybe_attach_backtrace(e, 0); - } - }; - let g$0 = g; - var _b_ = g(i); - caml_call2(Stdlib_Printf[3], _a_, _b_); - var _c_ = i + 1 | 0; + return 0 === x ? 1 : runtime.caml_mul(i$0, app(g$0, x - 1 | 0)); + }, + g = function(x){return app(f$0, x);}; + let f$0 = f, g$0 = g; + var _c_ = app(f, i); + caml_call2(Stdlib_Printf[3], _a_, _c_); + var _b_ = i + 1 | 0; if(4 === i) return 0; - i = _c_; + i = _b_; } } - //end |}] + //end + |}] diff --git a/compiler/tests-compiler/global_deadcode.ml b/compiler/tests-compiler/global_deadcode.ml index e57d38f251..f57ff1a60e 100644 --- a/compiler/tests-compiler/global_deadcode.ml +++ b/compiler/tests-compiler/global_deadcode.ml @@ -92,12 +92,15 @@ let%expect_test "Omit unused fields" = let program = compile_and_parse {| + let l = ref [] + let f b x = - for i = 0 to 2 do prerr_endline "X" done; (* Prevent inlining *) + l := (fun y -> x + y) :: !l; (* Prevent inlining *) let t = if b then (1, 2, x) else (3, x, 4) in let (u, _, v) = t in (u, v) - in print_int (fst (f true 1) + snd (f false 2)) + + let () = print_int (fst (f true 1) + snd (f false 2)) |} in (* Expect second field in each triple to be omitted. *) @@ -105,18 +108,12 @@ let%expect_test "Omit unused fields" = [%expect {| function f(b, x){ - var i = 0; - for(;;){ - caml_call1(Stdlib[53], cst_X); - var _c_ = i + 1 | 0; - if(2 === i){ - var t = b ? [0, 1, , x] : [0, 3, , 4], v = t[3], u = t[1]; - return [0, u, v]; - } - i = _c_; - } + l[1] = [0, function(y){return x + y | 0;}, l[1]]; + var t = b ? [0, 1, , x] : [0, 3, , 4], v = t[3], u = t[1]; + return [0, u, v]; } - //end |}] + //end + |}] let%expect_test "Omit unused return expressions" = let program = From 9716b415d2a619745c632719664ebc343f8623fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=B4me=20Vouillon?= Date: Fri, 25 Apr 2025 20:06:07 +0200 Subject: [PATCH 7/7] Less aggressive functor inlining for JavaScript code --- compiler/lib/inline.ml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/compiler/lib/inline.ml b/compiler/lib/inline.ml index 0644f0c538..258bad7538 100644 --- a/compiler/lib/inline.ml +++ b/compiler/lib/inline.ml @@ -324,7 +324,9 @@ let interesting_parameters ~context info = code elimination, ... *) let functor_like ~context info = - (context.aggressive || body_size ~context info <= 15) + (match Config.target () with + | `Wasm when context.aggressive -> true + | _ -> body_size ~context info <= 15) && (not info.recursive) && (not (contains_loop ~context info)) && returns_a_block ~context info